diff --git a/html/115write-byte.subx.html b/html/115write-byte.subx.html index d0e3c0cb..e9fa265a 100644 --- a/html/115write-byte.subx.html +++ b/html/115write-byte.subx.html @@ -501,8 +501,8 @@ if ('onhashchange' in window) { 439 # current read index 440 0/imm32 441 # line -442 0x80/imm32 # 128 bytes -443 # data (8 lines x 16 bytes/line) +442 0x100/imm32 # 256 bytes +443 # data (16 lines x 16 bytes/line) 444 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 445 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 446 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 @@ -511,22 +511,30 @@ if ('onhashchange' in window) { 449 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 450 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 451 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 -452 -453 # a test buffered file for _test-error-stream -454 _test-error-buffered-file: # buffered-file -455 # file descriptor or (addr stream byte) -456 _test-error-stream/imm32 -457 $_test-error-buffered-file->buffer: -458 # current write index -459 0/imm32 -460 # current read index -461 0/imm32 -462 # size -463 6/imm32 -464 # data -465 00 00 00 00 00 00 # 6 bytes -466 -467 # . . vim:nowrap:textwidth=0 +452 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +453 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +454 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +455 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +456 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +457 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +458 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +459 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 +460 +461 # a test buffered file for _test-error-stream +462 _test-error-buffered-file: # buffered-file +463 # file descriptor or (addr stream byte) +464 _test-error-stream/imm32 +465 $_test-error-buffered-file->buffer: +466 # current write index +467 0/imm32 +468 # current read index +469 0/imm32 +470 # size +471 6/imm32 +472 # data +473 00 00 00 00 00 00 # 6 bytes +474 +475 # . . vim:nowrap:textwidth=0 diff --git a/html/131table.subx.html b/html/131table.subx.html index accb82cd..78ebde34 100644 --- a/html/131table.subx.html +++ b/html/131table.subx.html @@ -1552,7 +1552,7 @@ if ('onhashchange' in window) { 1491 # eax = get-or-stop(table, "code", row-size=12, msg, _test-error-buffered-file, ed) 1492 # . . push args 1493 52/push-edx/ed -1494 68/push _test-error-buffered-file/imm32 +1494 68/push _test-error-buffered-file/imm32 1495 68/push "foo"/imm32/abort-prefix 1496 68/push 0xc/imm32/row-size 1497 68/push "code"/imm32 @@ -1577,7 +1577,7 @@ if ('onhashchange' in window) { 1516 # eax = get-or-stop(table, "data", row-size=12, msg, _test-error-buffered-file, ed) 1517 # . . push args 1518 52/push-edx/ed -1519 68/push _test-error-buffered-file/imm32 +1519 68/push _test-error-buffered-file/imm32 1520 68/push "foo"/imm32/abort-prefix 1521 68/push 0xc/imm32/row-size 1522 68/push "data"/imm32 @@ -1788,7 +1788,7 @@ if ('onhashchange' in window) { 1727 # eax = get-slice-or-stop(table, slice, row-size=12, msg, _test-error-buffered-file, ed) 1728 # . . push args 1729 52/push-edx/ed -1730 68/push _test-error-buffered-file/imm32 +1730 68/push _test-error-buffered-file/imm32 1731 68/push "foo"/imm32/abort-prefix 1732 68/push 0xc/imm32/row-size 1733 53/push-ebx/slice @@ -1825,7 +1825,7 @@ if ('onhashchange' in window) { 1764 # eax = get-slice-or-stop(table, slice, row-size=12, msg, _test-error-buffered-file, ed) 1765 # . . push args 1766 52/push-edx/ed -1767 68/push _test-error-buffered-file/imm32 +1767 68/push _test-error-buffered-file/imm32 1768 68/push "foo"/imm32/abort-prefix 1769 68/push 0xc/imm32/row-size 1770 53/push-ebx/slice diff --git a/html/304screen.subx.html b/html/304screen.subx.html index 7a756daf..c2799cc8 100644 --- a/html/304screen.subx.html +++ b/html/304screen.subx.html @@ -18,6 +18,7 @@ a { color:inherit; } .LineNr { } .SpecialChar { color: #d70000; } .subxS1Comment { color: #0000af; } +.CommentedCode { color: #8a8a8a; } .subxFunction { color: #af5f00; text-decoration: underline; } .Constant { color: #008787; } .subxMinorFunction { color: #875f5f; } @@ -511,8 +512,11 @@ if ('onhashchange' in window) { 453 0x1b 454 455 Terminal-filename: # (addr kernel-string) -456 # "/dev/null" +456 # "/dev/tty" 457 2f/slash 64/d 65/e 76/v 2f/slash 74/t 74/t 79/y 0/nul +458 # on Linux console +459 #? # "/dev/console" +460 #? 2f/slash 64/d 65/e 76/v 2f/slash 63/c 6f/o 6e/n 73/s 6f/o 6c/l 65/e 0/nul diff --git a/html/400.mu.html b/html/400.mu.html index 4eb1ffac..7502b30a 100644 --- a/html/400.mu.html +++ b/html/400.mu.html @@ -82,10 +82,10 @@ if ('onhashchange' in window) { 27 # Many functions here may not be usable yet because of missing features 28 # (global variable support, etc.) 29 sig check-ints-equal a: int, b: int, msg: (addr array byte) - 30 sig kernel-string-equal? s: (addr kernel-string), benchmark: (addr array byte) -> result/eax: boolean + 30 sig kernel-string-equal? s: (addr kernel-string), benchmark: (addr array byte) -> _/eax: boolean 31 sig new-segment len: int, ad: (addr allocation-descriptor) - 32 sig string-equal? s: (addr array byte), benchmark: (addr array byte) -> result/eax: boolean - 33 sig string-starts-with? s: (addr array byte), benchmark: (addr array byte) -> result/eax: boolean + 32 sig string-equal? s: (addr array byte), benchmark: (addr array byte) -> _/eax: boolean + 33 sig string-starts-with? s: (addr array byte), benchmark: (addr array byte) -> _/eax: boolean 34 sig check-strings-equal s: (addr array byte), expected: (addr array byte), msg: (addr array byte) 35 sig clear-stream f: (addr stream _) 36 sig rewind-stream f: (addr stream _) @@ -93,20 +93,20 @@ if ('onhashchange' in window) { 38 sig trace line: (addr array byte) 39 sig check-trace-contains line: (addr string), msg: (addr string) 40 sig check-trace-scans-to line: (addr string), msg: (addr string) - 41 sig trace-scan line: (addr array byte) -> result/eax: boolean - 42 sig next-line-matches? t: (addr stream byte), line: (addr array byte) -> result/eax: boolean + 41 sig trace-scan line: (addr array byte) -> _/eax: boolean + 42 sig next-line-matches? t: (addr stream byte), line: (addr array byte) -> _/eax: boolean 43 sig skip-next-line t: (addr stream byte) 44 sig clear-trace-stream 45 sig write f: (addr stream byte), s: (addr array byte) # writing to file descriptor not supported; use buffered-file - 46 sig stream-data-equal? f: (addr stream byte), s: (addr array byte) -> result/eax: boolean + 46 sig stream-data-equal? f: (addr stream byte), s: (addr array byte) -> _/eax: boolean 47 sig check-stream-equal f: (addr stream byte), s: (addr array byte), msg: (addr array byte) - 48 sig next-stream-line-equal? f: (addr stream byte), s: (addr array byte) -> result/eax: boolean + 48 sig next-stream-line-equal? f: (addr stream byte), s: (addr array byte) -> _/eax: boolean 49 sig check-next-stream-line-equal f: (addr stream byte), s: (addr array byte), msg: (addr array byte) 50 sig tailor-exit-descriptor ed: (addr exit-descriptor), nbytes: int 51 sig stop ed: (addr exit-descriptor), value: int - 52 #sig read f: fd or (addr stream byte), s: (addr stream byte) -> num-bytes-read/eax: int - 53 sig read-byte-buffered f: (addr buffered-file) -> byte-or-Eof/eax: byte - 54 sig read-byte s: (addr stream byte) -> result/eax: byte + 52 #sig read f: fd or (addr stream byte), s: (addr stream byte) -> _/eax: int + 53 sig read-byte-buffered f: (addr buffered-file) -> _/eax: byte + 54 sig read-byte s: (addr stream byte) -> _/eax: byte 55 #sig write-stream f: fd or (addr stream byte), s: (addr stream byte) 56 #sig error ed: (addr exit-descriptor), out: fd or (addr stream byte), msg: (addr array byte) 57 sig write-byte-buffered f: (addr buffered-file), n: int @@ -120,22 +120,22 @@ if ('onhashchange' in window) { 65 sig write-int32-hex-bits f: (addr stream byte), n: int, bits: int 66 sig write-int32-hex-buffered f: (addr buffered-file), n: int 67 sig write-int32-hex-bits-buffered f: (addr buffered-file), n: int, bits: int - 68 sig is-hex-int? in: (addr slice) -> result/eax: boolean - 69 sig parse-hex-int in: (addr array byte) -> result/eax: int - 70 sig parse-hex-int-from-slice in: (addr slice) -> result/eax: int - 71 #sig parse-hex-int-helper start: (addr byte), end: (addr byte) -> result/eax: int - 72 sig is-hex-digit? c: byte -> result/eax: boolean + 68 sig is-hex-int? in: (addr slice) -> _/eax: boolean + 69 sig parse-hex-int in: (addr array byte) -> _/eax: int + 70 sig parse-hex-int-from-slice in: (addr slice) -> _/eax: int + 71 #sig parse-hex-int-helper start: (addr byte), end: (addr byte) -> _/eax: int + 72 sig is-hex-digit? c: byte -> _/eax: boolean 73 #sig from-hex-char in/eax: byte -> out/eax: nibble - 74 sig parse-decimal-int in: (addr array byte) -> result/eax: int - 75 sig parse-decimal-int-from-slice in: (addr slice) -> result/eax: int - 76 sig parse-decimal-int-from-stream in: (addr stream byte) -> result/eax: int - 77 #sig parse-decimal-int-helper start: (addr byte), end: (addr byte) -> result/eax: int - 78 sig decimal-size n: int -> result/eax: int + 74 sig parse-decimal-int in: (addr array byte) -> _/eax: int + 75 sig parse-decimal-int-from-slice in: (addr slice) -> _/eax: int + 76 sig parse-decimal-int-from-stream in: (addr stream byte) -> _/eax: int + 77 #sig parse-decimal-int-helper start: (addr byte), end: (addr byte) -> _/eax: int + 78 sig decimal-size n: int -> _/eax: int 79 sig error-byte ed: (addr exit-descriptor), out: (addr buffered-file), msg: (addr array byte), n: byte 80 #sig allocate ad: (addr allocation-descriptor), n: int, out: (addr handle _) 81 #sig allocate-raw ad: (addr allocation-descriptor), n: int, out: (addr handle _) - 82 sig lookup h: (handle _T) -> result/eax: (addr _T) - 83 sig handle-equal? a: (handle _T), b: (handle _T) -> result/eax: boolean + 82 sig lookup h: (handle _T) -> _/eax: (addr _T) + 83 sig handle-equal? a: (handle _T), b: (handle _T) -> _/eax: boolean 84 sig copy-handle src: (handle _T), dest: (addr handle _T) 85 #sig allocate-region ad: (addr allocation-descriptor), n: int, out: (addr handle allocation-descriptor) 86 #sig allocate-array ad: (addr allocation-descriptor), n: int, out: (addr handle _) @@ -144,9 +144,9 @@ if ('onhashchange' in window) { 89 #sig new-stream ad: (addr allocation-descriptor), length: int, elemsize: int, out: (addr handle stream _) 90 sig read-line-buffered f: (addr buffered-file), s: (addr stream byte) 91 sig read-line f: (addr stream byte), s: (addr stream byte) - 92 sig slice-empty? s: (addr slice) -> result/eax: boolean - 93 sig slice-equal? s: (addr slice), p: (addr array byte) -> result/eax: boolean - 94 sig slice-starts-with? s: (addr slice), head: (addr array byte) -> result/eax: boolean + 92 sig slice-empty? s: (addr slice) -> _/eax: boolean + 93 sig slice-equal? s: (addr slice), p: (addr array byte) -> _/eax: boolean + 94 sig slice-starts-with? s: (addr slice), head: (addr array byte) -> _/eax: boolean 95 sig write-slice out: (addr stream byte), s: (addr slice) 96 sig write-slice-buffered out: (addr buffered-file), s: (addr slice) 97 sig slice-to-string ad: (addr allocation-descriptor), in: (addr slice), out: (addr handle array byte) @@ -156,53 +156,53 @@ if ('onhashchange' in window) { 101 sig skip-chars-matching-whitespace in: (addr stream byte) 102 sig skip-chars-not-matching in: (addr stream byte), delimiter: byte 103 sig skip-chars-not-matching-whitespace in: (addr stream byte) -104 #sig skip-chars-matching-in-slice curr: (addr byte), end: (addr byte), delimiter: byte -> curr/eax: (addr byte) -105 #sig skip-chars-matching-whitespace-in-slice curr: (addr byte), end: (addr byte) -> curr/eax: (addr byte) -106 #sig skip-chars-not-matching-in-slice curr: (addr byte), end: (addr byte), delimiter: byte -> curr/eax: (addr byte) -107 #sig skip-chars-not-matching-whitespace-in-slice curr: (addr byte), end: (addr byte) -> curr/eax: (addr byte) +104 #sig skip-chars-matching-in-slice curr: (addr byte), end: (addr byte), delimiter: byte -> _/eax: (addr byte) +105 #sig skip-chars-matching-whitespace-in-slice curr: (addr byte), end: (addr byte) -> _/eax: (addr byte) +106 #sig skip-chars-not-matching-in-slice curr: (addr byte), end: (addr byte), delimiter: byte -> _/eax: (addr byte) +107 #sig skip-chars-not-matching-whitespace-in-slice curr: (addr byte), end: (addr byte) -> _/eax: (addr byte) 108 sig skip-string line: (addr stream byte) -109 #sig skip-string-in-slice curr: (addr byte), end: (addr byte) -> curr/eax: (addr byte) +109 #sig skip-string-in-slice curr: (addr byte), end: (addr byte) -> _/eax: (addr byte) 110 sig skip-until-close-paren line: (addr stream byte) -111 #sig skip-until-close-paren-in-slice curr: (addr byte), end: (addr byte) -> curr/eax: (addr byte) +111 #sig skip-until-close-paren-in-slice curr: (addr byte), end: (addr byte) -> _/eax: (addr byte) 112 sig write-stream-data f: (addr buffered-file), s: (addr stream byte) 113 sig write-int32-decimal out: (addr stream byte), n: int -114 sig is-decimal-digit? c: grapheme -> result/eax: boolean -115 sig to-decimal-digit in: grapheme -> out/eax: int +114 sig is-decimal-digit? c: grapheme -> _/eax: boolean +115 sig to-decimal-digit in: grapheme -> _/eax: int 116 sig next-word line: (addr stream byte), out: (addr slice) -117 sig has-metadata? word: (addr slice), s: (addr string) -> result/eax: boolean -118 sig is-valid-name? in: (addr slice) -> result/eax: boolean -119 sig is-label? word: (addr slice) -> result/eax: boolean +117 sig has-metadata? word: (addr slice), s: (addr string) -> _/eax: boolean +118 sig is-valid-name? in: (addr slice) -> _/eax: boolean +119 sig is-label? word: (addr slice) -> _/eax: boolean 120 sig emit-hex out: (addr buffered-file), n: int, width: int 121 sig emit out: (addr buffered-file), word: (addr slice), width: int -122 #sig get table: (addr stream {(handle array byte), T}), key: (addr array byte), row-size: int, abort-message-prefix: (addr array byte) -> result/eax: (addr T) -123 #sig get-slice table: (addr stream {(handle array byte), T}), key: (addr slice), row-size: int, abort-message-prefix: (addr array byte) -> result/eax: (addr T) -124 #sig get-or-insert table: (addr stream {(handle array byte), T}), key: (addr array byte), row-size: int, ad: (addr allocation-descriptor) -> result/eax: (addr T) -125 #sig get-or-insert-handle table: (addr stream {(handle array byte), T}), key: (handle array byte), row-size: int -> result/eax: (addr T) -126 #sig get-or-insert-slice table: (addr stream {(handle array byte), T}), key: (addr slice), row-size: int, ad: (addr allocation-descriptor) -> result/eax: (addr T) +122 #sig get table: (addr stream {(handle array byte), T}), key: (addr array byte), row-size: int, abort-message-prefix: (addr array byte) -> _/eax: (addr T) +123 #sig get-slice table: (addr stream {(handle array byte), T}), key: (addr slice), row-size: int, abort-message-prefix: (addr array byte) -> _/eax: (addr T) +124 #sig get-or-insert table: (addr stream {(handle array byte), T}), key: (addr array byte), row-size: int, ad: (addr allocation-descriptor) -> _/eax: (addr T) +125 #sig get-or-insert-handle table: (addr stream {(handle array byte), T}), key: (handle array byte), row-size: int -> _/eax: (addr T) +126 #sig get-or-insert-slice table: (addr stream {(handle array byte), T}), key: (addr slice), row-size: int, ad: (addr allocation-descriptor) -> _/eax: (addr T) 127 #sig get-or-stop table: (addr stream {(handle array byte), T}), key: (addr array byte), row-size: int 128 #sig get-slice-or-stop table: (addr stream {(handle array byte), _}), key: (addr slice), row-size: int -129 #sig maybe-get table: (addr stream {(handle array byte), T}), key: (addr array byte), row-size: int -> result/eax: (addr T) -130 #sig maybe-get-slice table: (addr stream {(handle array byte), T}), key: (addr slice), row-size: int -> result/eax: (addr T) +129 #sig maybe-get table: (addr stream {(handle array byte), T}), key: (addr array byte), row-size: int -> _/eax: (addr T) +130 #sig maybe-get-slice table: (addr stream {(handle array byte), T}), key: (addr slice), row-size: int -> _/eax: (addr T) 131 sig slurp f: (addr buffered-file), s: (addr stream byte) -132 sig compute-width word: (addr array byte) -> result/eax: int -133 sig compute-width-of-slice s: (addr slice) -> result/eax: int +132 sig compute-width word: (addr array byte) -> _/eax: int +133 sig compute-width-of-slice s: (addr slice) -> _/eax: int 134 sig emit-hex-array out: (addr buffered-file), arr: (addr array byte) 135 sig next-word-or-string line: (addr stream byte), out: (addr slice) 136 sig write-int out: (addr stream byte), n: int 137 #sig clear-stack s: (addr stack) 138 #sig push s: (addr stack), n: int -139 #sig pop s: (addr stack) -> n/eax: int -140 #sig top s: (addr stack) -> n/eax: int -141 sig array-equal? a: (addr array int), b: (addr array int) -> result/eax: boolean +139 #sig pop s: (addr stack) -> _/eax: int +140 #sig top s: (addr stack) -> _/eax: int +141 sig array-equal? a: (addr array int), b: (addr array int) -> _/eax: boolean 142 sig parse-array-of-ints s: (addr array byte), out: (addr handle array int) 143 sig parse-array-of-decimal-ints s: (addr array byte), out: (addr handle array int) 144 sig check-array-equal a: (addr array int), expected: (addr string), msg: (addr string) 145 #sig push-n-zero-bytes n: int 146 sig kernel-string-to-string ad: (addr allocation-descriptor), in: (addr kernel-string), out: (addr handle array byte) -147 sig kernel-string-length in: (addr kernel-string) -> result/eax: int +147 sig kernel-string-length in: (addr kernel-string) -> _/eax: int 148 sig enable-screen-grid-mode 149 sig enable-screen-type-mode -150 sig real-screen-size -> nrows/eax: int, ncols/ecx: int +150 sig real-screen-size -> _/eax: int, _/ecx: int 151 sig clear-real-screen 152 sig move-cursor-on-real-screen row: int, column: int 153 sig print-string-to-real-screen s: (addr array byte) @@ -223,19 +223,19 @@ if ('onhashchange' in window) { 168 sig show-cursor-on-real-screen 169 sig enable-keyboard-immediate-mode 170 sig enable-keyboard-type-mode -171 sig read-key-from-real-keyboard -> result/eax: grapheme +171 sig read-key-from-real-keyboard -> _/eax: grapheme 172 sig read-line-from-real-keyboard out: (addr stream byte) 173 sig open filename: (addr array byte), write?: boolean, out: (addr handle buffered-file) 174 sig populate-buffered-file-containing contents: (addr array byte), out: (addr handle buffered-file) 175 sig new-buffered-file out: (addr handle buffered-file) -176 #sig size in: (addr array _) -> result/eax: int +176 #sig size in: (addr array _) -> _/eax: int 177 -178 sig stream-empty? s: (addr stream _) -> result/eax: boolean -179 sig stream-full? s: (addr stream _) -> result/eax: boolean +178 sig stream-empty? s: (addr stream _) -> _/eax: boolean +179 sig stream-full? s: (addr stream _) -> _/eax: boolean 180 sig stream-to-array in: (addr stream _), out: (addr handle array _) 181 sig unquote-stream-to-array in: (addr stream _), out: (addr handle array _) -182 sig stream-first s: (addr stream byte) -> result/eax: byte -183 sig stream-final s: (addr stream byte) -> result/eax: byte +182 sig stream-first s: (addr stream byte) -> _/eax: byte +183 sig stream-final s: (addr stream byte) -> _/eax: byte 184 185 #sig copy-bytes src: (addr byte), dest: (addr byte), n: int 186 sig copy-array-object src: (addr array _), dest-ah: (addr handle array _) diff --git a/html/apps/browse/main.mu.html b/html/apps/browse/main.mu.html index 3974fe09..7bc920d5 100644 --- a/html/apps/browse/main.mu.html +++ b/html/apps/browse/main.mu.html @@ -78,382 +78,379 @@ if ('onhashchange' in window) { 19 return 0 # TODO: get at Num-test-failures somehow 20 } 21 # otherwise interactive mode - 22 var result/ebx: int <- interactive args-on-stack - 23 return result - 24 } - 25 - 26 fn interactive _args: (addr array addr array byte) -> _/ebx: int { - 27 # initialize fs from args[1] - 28 var args/eax: (addr array addr array byte) <- copy _args - 29 var arg/eax: (addr addr array byte) <- index args, 1 - 30 var filename/eax: (addr array byte) <- copy *arg - 31 var file-storage: (handle buffered-file) - 32 var file-storage-addr/esi: (addr handle buffered-file) <- address file-storage - 33 open filename, 0, file-storage-addr - 34 var _fs/eax: (addr buffered-file) <- lookup file-storage - 35 var fs/esi: (addr buffered-file) <- copy _fs - 36 # if no file, exit - 37 { - 38 compare fs, 0 - 39 break-if-!= - 40 print-string-to-real-screen "file not found\n" - 41 return 1 - 42 } - 43 # - 44 enable-screen-grid-mode - 45 enable-keyboard-immediate-mode - 46 # initialize screen state - 47 var paginated-screen-storage: paginated-screen - 48 var paginated-screen/eax: (addr paginated-screen) <- address paginated-screen-storage - 49 initialize-paginated-screen paginated-screen, 0x40, 2, 5 - 50 normal-text paginated-screen - 51 # - 52 { - 53 render paginated-screen, fs - 54 var key/eax: grapheme <- read-key-from-real-keyboard - 55 compare key, 0x71 # 'q' - 56 loop-if-!= - 57 } - 58 enable-keyboard-type-mode - 59 enable-screen-type-mode - 60 return 0 - 61 } - 62 - 63 fn render screen: (addr paginated-screen), fs: (addr buffered-file) { - 64 start-drawing screen - 65 render-normal screen, fs - 66 } - 67 - 68 fn test-render-multicolumn-text { - 69 # input text - 70 var input-storage: (handle buffered-file) - 71 var input-ah/eax: (addr handle buffered-file) <- address input-storage - 72 populate-buffered-file-containing "abcdefgh", input-ah - 73 var in/eax: (addr buffered-file) <- lookup input-storage - 74 # output screen - 75 var pg: paginated-screen - 76 var pg-addr/ecx: (addr paginated-screen) <- address pg - 77 initialize-fake-paginated-screen pg-addr, 3, 6, 2, 1, 1 # 3 rows, 6 columns, 2 pages * 2 columns each - 78 # - 79 render pg-addr, in - 80 var screen-ah/eax: (addr handle screen) <- get pg, screen - 81 var screen/eax: (addr screen) <- lookup *screen-ah - 82 check-screen-row screen, 1, " ", "F - test-render-multicolumn-text/row1" - 83 check-screen-row screen, 2, " ab ef", "F - test-render-multicolumn-text/row2" - 84 check-screen-row screen, 3, " cd gh", "F - test-render-multicolumn-text/row3" - 85 } - 86 - 87 fn test-render-heading-text { - 88 # input text - 89 var input-storage: (handle buffered-file) - 90 var input-ah/eax: (addr handle buffered-file) <- address input-storage - 91 populate-buffered-file-containing "# abc\n\ndef", input-ah - 92 var in/eax: (addr buffered-file) <- lookup input-storage - 93 # output screen - 94 var pg: paginated-screen - 95 var pg-addr/ecx: (addr paginated-screen) <- address pg - 96 initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1 # 6 columns, single page - 97 # - 98 render pg-addr, in - 99 var screen-ah/eax: (addr handle screen) <- get pg, screen -100 var screen/eax: (addr screen) <- lookup *screen-ah -101 check-screen-row screen, 1, " ", "F - test-render-heading-text/row1" -102 check-screen-row-in-color screen, 0xa0, 2, " abc ", "F - test-render-heading-text/heading" -103 check-screen-row screen, 3, " ", "F - test-render-heading-text/row3" -104 check-screen-row screen, 4, " def ", "F - test-render-heading-text/row4" -105 } -106 -107 fn test-render-bold-text { -108 # input text -109 var input-storage: (handle buffered-file) -110 var input-ah/eax: (addr handle buffered-file) <- address input-storage -111 populate-buffered-file-containing "a *b* c", input-ah -112 var in/eax: (addr buffered-file) <- lookup input-storage -113 # output screen -114 var pg: paginated-screen -115 var pg-addr/ecx: (addr paginated-screen) <- address pg -116 initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1 # 6 columns, single page -117 # -118 render pg-addr, in -119 var screen-ah/eax: (addr handle screen) <- get pg, screen -120 var screen/eax: (addr screen) <- lookup *screen-ah -121 check-screen-row screen, 2, " a b c", "F - test-render-bold-text/text" -122 check-screen-row-in-bold screen, 2, " b ", "F - test-render-bold-text/bold" -123 } -124 -125 # terminals don't always support italics, so we'll just always render italics -126 # as bold. -127 fn test-render-pseudoitalic-text { -128 # input text -129 var input-storage: (handle buffered-file) -130 var input-ah/eax: (addr handle buffered-file) <- address input-storage -131 populate-buffered-file-containing "a _b_ c", input-ah -132 var in/eax: (addr buffered-file) <- lookup input-storage -133 # output screen -134 var pg: paginated-screen -135 var pg-addr/ecx: (addr paginated-screen) <- address pg -136 initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1 # 6 columns, single page -137 # -138 render pg-addr, in -139 var screen-ah/eax: (addr handle screen) <- get pg, screen -140 var screen/eax: (addr screen) <- lookup *screen-ah -141 check-screen-row screen, 2, " a b c", "F - test-render-pseudoitalic-text/text" -142 check-screen-row-in-bold screen, 2, " b ", "F - test-render-pseudoitalic-text/bold" -143 } -144 -145 fn test-render-asterisk-in-text { -146 # input text -147 var input-storage: (handle buffered-file) -148 var input-ah/eax: (addr handle buffered-file) <- address input-storage -149 populate-buffered-file-containing "a*b*c", input-ah -150 var in/eax: (addr buffered-file) <- lookup input-storage -151 # output screen -152 var pg: paginated-screen -153 var pg-addr/ecx: (addr paginated-screen) <- address pg -154 initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1 # 6 columns, single page -155 # -156 render pg-addr, in -157 var screen-ah/eax: (addr handle screen) <- get pg, screen -158 var screen/eax: (addr screen) <- lookup *screen-ah -159 check-screen-row screen, 2, " a*b*c", "F - test-render-bold-text/text" -160 check-screen-row-in-bold screen, 2, " ", "F - test-render-bold-text/bold" -161 } -162 -163 fn render-normal screen: (addr paginated-screen), fs: (addr buffered-file) { -164 var newline-seen?/esi: boolean <- copy 0 # false -165 var start-of-paragraph?/edi: boolean <- copy 1 # true -166 var previous-grapheme/ebx: grapheme <- copy 0 -167 $render-normal:loop: { -168 # if done-drawing?(screen) break -169 var done?/eax: boolean <- done-drawing? screen -170 compare done?, 0 # false -171 break-if-!= -172 var c/eax: grapheme <- read-grapheme-buffered fs -173 $render-normal:loop-body: { -174 # if (c == EOF) break -175 compare c, 0xffffffff # EOF marker -176 break-if-= $render-normal:loop -177 -178 ## if (c == newline) perform some fairly sophisticated parsing for soft newlines -179 compare c, 0xa # newline -180 { -181 break-if-!= -182 # if it's the first newline, buffer it -183 compare newline-seen?, 0 -184 { -185 break-if-!= -186 newline-seen? <- copy 1 # true -187 break $render-normal:loop-body -188 } -189 # otherwise render two newlines -190 { -191 break-if-= -192 add-grapheme screen, 0xa # newline -193 add-grapheme screen, 0xa # newline -194 newline-seen? <- copy 0 # false -195 start-of-paragraph? <- copy 1 # true -196 break $render-normal:loop-body -197 } -198 } -199 # if start of paragraph and c == '#', switch to header -200 compare start-of-paragraph?, 0 -201 { -202 break-if-= -203 compare c, 0x23 # '#' -204 { -205 break-if-!= -206 render-header-line screen, fs -207 newline-seen? <- copy 1 # true -208 break $render-normal:loop-body -209 } -210 } -211 # c is not a newline -212 start-of-paragraph? <- copy 0 # false -213 # if c is unprintable (particularly a '\r' CR), skip it -214 compare c, 0x20 -215 loop-if-< $render-normal:loop -216 # If there's a newline buffered and c is a space, print the buffered -217 # newline (hard newline). -218 # If there's a newline buffered and c is not a newline or space, print a -219 # space (soft newline). -220 compare newline-seen?, 0 # false -221 $render-normal:flush-buffered-newline: { -222 break-if-= -223 newline-seen? <- copy 0 # false -224 { -225 compare c, 0x20 -226 break-if-!= -227 add-grapheme screen, 0xa # newline -228 break $render-normal:flush-buffered-newline -229 } -230 add-grapheme screen, 0x20 # space -231 # fall through to print c -232 } -233 ## end soft newline support -234 -235 $render-normal:whitespace-separated-regions: { -236 # if previous-grapheme wasn't whitespace, skip this block -237 { -238 compare previous-grapheme, 0x20 # space -239 break-if-= -240 compare previous-grapheme, 0xa # newline -241 break-if-= -242 break $render-normal:whitespace-separated-regions -243 } -244 # if (c == '*') switch to bold -245 compare c, 0x2a # '*' -246 { -247 break-if-!= -248 start-color-on-paginated-screen screen, 0xec, 7 # 236 = darkish gray -249 start-bold-on-paginated-screen screen -250 render-until-asterisk screen, fs -251 normal-text screen -252 break $render-normal:loop-body -253 } -254 # if (c == '_') switch to bold -255 compare c, 0x5f # '_' -256 { -257 break-if-!= -258 start-color-on-paginated-screen screen, 0xec, 7 # 236 = darkish gray -259 start-bold-on-paginated-screen screen -260 render-until-underscore screen, fs -261 normal-text screen -262 break $render-normal:loop-body -263 } -264 } -265 # -266 add-grapheme screen, c -267 } # $render-normal:loop-body -268 previous-grapheme <- copy c -269 loop -270 } # $render-normal:loop -271 } -272 -273 fn render-header-line screen: (addr paginated-screen), fs: (addr buffered-file) { -274 $render-header-line:body: { -275 # compute color based on number of '#'s -276 var header-level/esi: int <- copy 1 # caller already grabbed one -277 var c/eax: grapheme <- copy 0 -278 { -279 # if done-drawing?(screen) return -280 { -281 var done?/eax: boolean <- done-drawing? screen -282 compare done?, 0 # false -283 break-if-!= $render-header-line:body -284 } -285 # -286 c <- read-grapheme-buffered fs -287 # if (c != '#') break -288 compare c, 0x23 # '#' -289 break-if-!= -290 # -291 header-level <- increment -292 # -293 loop -294 } -295 start-heading screen, header-level -296 { -297 # if done-drawing?(screen) break -298 { -299 var done?/eax: boolean <- done-drawing? screen -300 compare done?, 0 # false -301 break-if-!= -302 } -303 # -304 c <- read-grapheme-buffered fs -305 # if (c == EOF) break -306 compare c, 0xffffffff # EOF marker + 22 var args/eax: (addr array addr array byte) <- copy args-on-stack + 23 var arg/eax: (addr addr array byte) <- index args, 1 + 24 var filename/eax: (addr array byte) <- copy *arg + 25 var file-storage: (handle buffered-file) + 26 var file-storage-addr/esi: (addr handle buffered-file) <- address file-storage + 27 open filename, 0, file-storage-addr + 28 var fs/eax: (addr buffered-file) <- lookup file-storage + 29 # if no file, exit + 30 { + 31 compare fs, 0 + 32 break-if-!= + 33 print-string-to-real-screen "file not found\n" + 34 return 1 + 35 } + 36 # + 37 interactive fs + 38 return 0 + 39 } + 40 + 41 fn interactive fs: (addr buffered-file) { + 42 enable-screen-grid-mode + 43 enable-keyboard-immediate-mode + 44 # initialize screen state + 45 var paginated-screen-storage: paginated-screen + 46 var paginated-screen/eax: (addr paginated-screen) <- address paginated-screen-storage + 47 initialize-paginated-screen paginated-screen, 0x40, 2, 5 + 48 normal-text paginated-screen + 49 # + 50 { + 51 render paginated-screen, fs + 52 var key/eax: grapheme <- read-key-from-real-keyboard + 53 compare key, 0x71 # 'q' + 54 loop-if-!= + 55 } + 56 enable-keyboard-type-mode + 57 enable-screen-type-mode + 58 } + 59 + 60 fn render screen: (addr paginated-screen), fs: (addr buffered-file) { + 61 start-drawing screen + 62 render-normal screen, fs + 63 } + 64 + 65 fn test-render-multicolumn-text { + 66 # input text + 67 var input-storage: (handle buffered-file) + 68 var input-ah/eax: (addr handle buffered-file) <- address input-storage + 69 populate-buffered-file-containing "abcdefgh", input-ah + 70 var in/eax: (addr buffered-file) <- lookup input-storage + 71 # output screen + 72 var pg: paginated-screen + 73 var pg-addr/ecx: (addr paginated-screen) <- address pg + 74 initialize-fake-paginated-screen pg-addr, 3, 6, 2, 1, 1 # 3 rows, 6 columns, 2 pages * 2 columns each + 75 # + 76 render pg-addr, in + 77 var screen-ah/eax: (addr handle screen) <- get pg, screen + 78 var screen/eax: (addr screen) <- lookup *screen-ah + 79 check-screen-row screen, 1, " ", "F - test-render-multicolumn-text/row1" + 80 check-screen-row screen, 2, " ab ef", "F - test-render-multicolumn-text/row2" + 81 check-screen-row screen, 3, " cd gh", "F - test-render-multicolumn-text/row3" + 82 } + 83 + 84 fn test-render-heading-text { + 85 # input text + 86 var input-storage: (handle buffered-file) + 87 var input-ah/eax: (addr handle buffered-file) <- address input-storage + 88 populate-buffered-file-containing "# abc\n\ndef", input-ah + 89 var in/eax: (addr buffered-file) <- lookup input-storage + 90 # output screen + 91 var pg: paginated-screen + 92 var pg-addr/ecx: (addr paginated-screen) <- address pg + 93 initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1 # 6 columns, single page + 94 # + 95 render pg-addr, in + 96 var screen-ah/eax: (addr handle screen) <- get pg, screen + 97 var screen/eax: (addr screen) <- lookup *screen-ah + 98 check-screen-row screen, 1, " ", "F - test-render-heading-text/row1" + 99 check-screen-row-in-color screen, 0xa0, 2, " abc ", "F - test-render-heading-text/heading" +100 check-screen-row screen, 3, " ", "F - test-render-heading-text/row3" +101 check-screen-row screen, 4, " def ", "F - test-render-heading-text/row4" +102 } +103 +104 fn test-render-bold-text { +105 # input text +106 var input-storage: (handle buffered-file) +107 var input-ah/eax: (addr handle buffered-file) <- address input-storage +108 populate-buffered-file-containing "a *b* c", input-ah +109 var in/eax: (addr buffered-file) <- lookup input-storage +110 # output screen +111 var pg: paginated-screen +112 var pg-addr/ecx: (addr paginated-screen) <- address pg +113 initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1 # 6 columns, single page +114 # +115 render pg-addr, in +116 var screen-ah/eax: (addr handle screen) <- get pg, screen +117 var screen/eax: (addr screen) <- lookup *screen-ah +118 check-screen-row screen, 2, " a b c", "F - test-render-bold-text/text" +119 check-screen-row-in-bold screen, 2, " b ", "F - test-render-bold-text/bold" +120 } +121 +122 # terminals don't always support italics, so we'll just always render italics +123 # as bold. +124 fn test-render-pseudoitalic-text { +125 # input text +126 var input-storage: (handle buffered-file) +127 var input-ah/eax: (addr handle buffered-file) <- address input-storage +128 populate-buffered-file-containing "a _b_ c", input-ah +129 var in/eax: (addr buffered-file) <- lookup input-storage +130 # output screen +131 var pg: paginated-screen +132 var pg-addr/ecx: (addr paginated-screen) <- address pg +133 initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1 # 6 columns, single page +134 # +135 render pg-addr, in +136 var screen-ah/eax: (addr handle screen) <- get pg, screen +137 var screen/eax: (addr screen) <- lookup *screen-ah +138 check-screen-row screen, 2, " a b c", "F - test-render-pseudoitalic-text/text" +139 check-screen-row-in-bold screen, 2, " b ", "F - test-render-pseudoitalic-text/bold" +140 } +141 +142 fn test-render-asterisk-in-text { +143 # input text +144 var input-storage: (handle buffered-file) +145 var input-ah/eax: (addr handle buffered-file) <- address input-storage +146 populate-buffered-file-containing "a*b*c", input-ah +147 var in/eax: (addr buffered-file) <- lookup input-storage +148 # output screen +149 var pg: paginated-screen +150 var pg-addr/ecx: (addr paginated-screen) <- address pg +151 initialize-fake-paginated-screen pg-addr, 8, 6, 5, 1, 1 # 6 columns, single page +152 # +153 render pg-addr, in +154 var screen-ah/eax: (addr handle screen) <- get pg, screen +155 var screen/eax: (addr screen) <- lookup *screen-ah +156 check-screen-row screen, 2, " a*b*c", "F - test-render-bold-text/text" +157 check-screen-row-in-bold screen, 2, " ", "F - test-render-bold-text/bold" +158 } +159 +160 fn render-normal screen: (addr paginated-screen), fs: (addr buffered-file) { +161 var newline-seen?/esi: boolean <- copy 0 # false +162 var start-of-paragraph?/edi: boolean <- copy 1 # true +163 var previous-grapheme/ebx: grapheme <- copy 0 +164 $render-normal:loop: { +165 # if done-drawing?(screen) break +166 var done?/eax: boolean <- done-drawing? screen +167 compare done?, 0 # false +168 break-if-!= +169 var c/eax: grapheme <- read-grapheme-buffered fs +170 $render-normal:loop-body: { +171 # if (c == EOF) break +172 compare c, 0xffffffff # EOF marker +173 break-if-= $render-normal:loop +174 +175 ## if (c == newline) perform some fairly sophisticated parsing for soft newlines +176 compare c, 0xa # newline +177 { +178 break-if-!= +179 # if it's the first newline, buffer it +180 compare newline-seen?, 0 +181 { +182 break-if-!= +183 newline-seen? <- copy 1 # true +184 break $render-normal:loop-body +185 } +186 # otherwise render two newlines +187 { +188 break-if-= +189 add-grapheme screen, 0xa # newline +190 add-grapheme screen, 0xa # newline +191 newline-seen? <- copy 0 # false +192 start-of-paragraph? <- copy 1 # true +193 break $render-normal:loop-body +194 } +195 } +196 # if start of paragraph and c == '#', switch to header +197 compare start-of-paragraph?, 0 +198 { +199 break-if-= +200 compare c, 0x23 # '#' +201 { +202 break-if-!= +203 render-header-line screen, fs +204 newline-seen? <- copy 1 # true +205 break $render-normal:loop-body +206 } +207 } +208 # c is not a newline +209 start-of-paragraph? <- copy 0 # false +210 # if c is unprintable (particularly a '\r' CR), skip it +211 compare c, 0x20 +212 loop-if-< $render-normal:loop +213 # If there's a newline buffered and c is a space, print the buffered +214 # newline (hard newline). +215 # If there's a newline buffered and c is not a newline or space, print a +216 # space (soft newline). +217 compare newline-seen?, 0 # false +218 $render-normal:flush-buffered-newline: { +219 break-if-= +220 newline-seen? <- copy 0 # false +221 { +222 compare c, 0x20 +223 break-if-!= +224 add-grapheme screen, 0xa # newline +225 break $render-normal:flush-buffered-newline +226 } +227 add-grapheme screen, 0x20 # space +228 # fall through to print c +229 } +230 ## end soft newline support +231 +232 $render-normal:whitespace-separated-regions: { +233 # if previous-grapheme wasn't whitespace, skip this block +234 { +235 compare previous-grapheme, 0x20 # space +236 break-if-= +237 compare previous-grapheme, 0xa # newline +238 break-if-= +239 break $render-normal:whitespace-separated-regions +240 } +241 # if (c == '*') switch to bold +242 compare c, 0x2a # '*' +243 { +244 break-if-!= +245 start-color-on-paginated-screen screen, 0xec, 7 # 236 = darkish gray +246 start-bold-on-paginated-screen screen +247 render-until-asterisk screen, fs +248 normal-text screen +249 break $render-normal:loop-body +250 } +251 # if (c == '_') switch to bold +252 compare c, 0x5f # '_' +253 { +254 break-if-!= +255 start-color-on-paginated-screen screen, 0xec, 7 # 236 = darkish gray +256 start-bold-on-paginated-screen screen +257 render-until-underscore screen, fs +258 normal-text screen +259 break $render-normal:loop-body +260 } +261 } +262 # +263 add-grapheme screen, c +264 } # $render-normal:loop-body +265 previous-grapheme <- copy c +266 loop +267 } # $render-normal:loop +268 } +269 +270 fn render-header-line screen: (addr paginated-screen), fs: (addr buffered-file) { +271 $render-header-line:body: { +272 # compute color based on number of '#'s +273 var header-level/esi: int <- copy 1 # caller already grabbed one +274 var c/eax: grapheme <- copy 0 +275 { +276 # if done-drawing?(screen) return +277 { +278 var done?/eax: boolean <- done-drawing? screen +279 compare done?, 0 # false +280 break-if-!= $render-header-line:body +281 } +282 # +283 c <- read-grapheme-buffered fs +284 # if (c != '#') break +285 compare c, 0x23 # '#' +286 break-if-!= +287 # +288 header-level <- increment +289 # +290 loop +291 } +292 start-heading screen, header-level +293 { +294 # if done-drawing?(screen) break +295 { +296 var done?/eax: boolean <- done-drawing? screen +297 compare done?, 0 # false +298 break-if-!= +299 } +300 # +301 c <- read-grapheme-buffered fs +302 # if (c == EOF) break +303 compare c, 0xffffffff # EOF marker +304 break-if-= +305 # if (c == newline) break +306 compare c, 0xa # newline 307 break-if-= -308 # if (c == newline) break -309 compare c, 0xa # newline -310 break-if-= -311 # -312 add-grapheme screen, c -313 # -314 loop -315 } -316 normal-text screen -317 } -318 } -319 -320 # colors for a light background, going from bright to dark (meeting up with bold-text) -321 fn start-heading screen: (addr paginated-screen), header-level: int { -322 $start-heading:body: { -323 start-bold-on-paginated-screen screen -324 compare header-level, 1 -325 { -326 break-if-!= -327 start-color-on-paginated-screen screen, 0xa0, 7 -328 break $start-heading:body -329 } -330 compare header-level, 2 -331 { -332 break-if-!= -333 start-color-on-paginated-screen screen, 0x7c, 7 -334 break $start-heading:body -335 } -336 compare header-level, 3 -337 { -338 break-if-!= -339 start-color-on-paginated-screen screen, 0x58, 7 -340 break $start-heading:body -341 } -342 compare header-level, 4 -343 { -344 break-if-!= -345 start-color-on-paginated-screen screen, 0x34, 7 -346 break $start-heading:body -347 } -348 start-color-on-paginated-screen screen, 0xe8, 7 -349 } -350 } -351 -352 fn render-until-asterisk screen: (addr paginated-screen), fs: (addr buffered-file) { -353 { -354 # if done-drawing?(screen) break -355 var done?/eax: boolean <- done-drawing? screen -356 compare done?, 0 # false -357 break-if-!= -358 # -359 var c/eax: grapheme <- read-grapheme-buffered fs -360 # if (c == EOF) break -361 compare c, 0xffffffff # EOF marker +308 # +309 add-grapheme screen, c +310 # +311 loop +312 } +313 normal-text screen +314 } +315 } +316 +317 # colors for a light background, going from bright to dark (meeting up with bold-text) +318 fn start-heading screen: (addr paginated-screen), header-level: int { +319 $start-heading:body: { +320 start-bold-on-paginated-screen screen +321 compare header-level, 1 +322 { +323 break-if-!= +324 start-color-on-paginated-screen screen, 0xa0, 7 +325 break $start-heading:body +326 } +327 compare header-level, 2 +328 { +329 break-if-!= +330 start-color-on-paginated-screen screen, 0x7c, 7 +331 break $start-heading:body +332 } +333 compare header-level, 3 +334 { +335 break-if-!= +336 start-color-on-paginated-screen screen, 0x58, 7 +337 break $start-heading:body +338 } +339 compare header-level, 4 +340 { +341 break-if-!= +342 start-color-on-paginated-screen screen, 0x34, 7 +343 break $start-heading:body +344 } +345 start-color-on-paginated-screen screen, 0xe8, 7 +346 } +347 } +348 +349 fn render-until-asterisk screen: (addr paginated-screen), fs: (addr buffered-file) { +350 { +351 # if done-drawing?(screen) break +352 var done?/eax: boolean <- done-drawing? screen +353 compare done?, 0 # false +354 break-if-!= +355 # +356 var c/eax: grapheme <- read-grapheme-buffered fs +357 # if (c == EOF) break +358 compare c, 0xffffffff # EOF marker +359 break-if-= +360 # if (c == '*') break +361 compare c, 0x2a # '*' 362 break-if-= -363 # if (c == '*') break -364 compare c, 0x2a # '*' -365 break-if-= -366 # -367 add-grapheme screen, c -368 # -369 loop -370 } -371 } -372 -373 fn render-until-underscore screen: (addr paginated-screen), fs: (addr buffered-file) { -374 { -375 # if done-drawing?(screen) break -376 var done?/eax: boolean <- done-drawing? screen -377 compare done?, 0 # false -378 break-if-!= -379 # -380 var c/eax: grapheme <- read-grapheme-buffered fs -381 # if (c == EOF) break -382 compare c, 0xffffffff # EOF marker +363 # +364 add-grapheme screen, c +365 # +366 loop +367 } +368 } +369 +370 fn render-until-underscore screen: (addr paginated-screen), fs: (addr buffered-file) { +371 { +372 # if done-drawing?(screen) break +373 var done?/eax: boolean <- done-drawing? screen +374 compare done?, 0 # false +375 break-if-!= +376 # +377 var c/eax: grapheme <- read-grapheme-buffered fs +378 # if (c == EOF) break +379 compare c, 0xffffffff # EOF marker +380 break-if-= +381 # if (c == '_') break +382 compare c, 0x5f # '_' 383 break-if-= -384 # if (c == '_') break -385 compare c, 0x5f # '_' -386 break-if-= -387 # -388 add-grapheme screen, c -389 # -390 loop -391 } -392 } -393 -394 fn normal-text screen: (addr paginated-screen) { -395 reset-formatting-on-paginated-screen screen -396 start-color-on-paginated-screen screen, 0xec, 7 # 236 = darkish gray -397 } +384 # +385 add-grapheme screen, c +386 # +387 loop +388 } +389 } +390 +391 fn normal-text screen: (addr paginated-screen) { +392 reset-formatting-on-paginated-screen screen +393 start-color-on-paginated-screen screen, 0xec, 7 # 236 = darkish gray +394 } diff --git a/html/apps/calls.subx.html b/html/apps/calls.subx.html index d7dd19b6..211c35f9 100644 --- a/html/apps/calls.subx.html +++ b/html/apps/calls.subx.html @@ -811,1015 +811,1059 @@ if ('onhashchange' in window) { 821 # ++line->read to skip ')' 822 # out->end = &line->data[line->read] 823 # return - 824 # if line->data[line->read] == ')' - 825 # ++line->read to skip ')' - 826 # # make sure there's nothing else of importance - 827 # if line->read >= line->write - 828 # out = {0, 0} - 829 # return - 830 # if line->data[line->read] != ' ' - 831 # abort - 832 # skip-chars-matching-whitespace(line) - 833 # if line->read >= line->write - 834 # out = {0, 0} - 835 # return - 836 # if line->data[line->read] == '#' # only thing permitted after ')' is a comment - 837 # out = {0, 0} - 838 # return - 839 # abort - 840 # # default case: read a word -- but no metadata - 841 # while true - 842 # if line->read >= line->write - 843 # break - 844 # if line->data[line->read] == ' ' + 824 # if line->data[line->read] == '(' + 825 # abort + 826 # if line->data[line->read] == ')' + 827 # ++line->read to skip ')' + 828 # # make sure there's nothing else of importance + 829 # if line->read >= line->write + 830 # out = {0, 0} + 831 # return + 832 # if line->data[line->read] != ' ' + 833 # abort + 834 # skip-chars-matching-whitespace(line) + 835 # if line->read >= line->write + 836 # out = {0, 0} + 837 # return + 838 # if line->data[line->read] == '#' # only thing permitted after ')' is a comment + 839 # out = {0, 0} + 840 # return + 841 # abort + 842 # # default case: read a word -- but no metadata + 843 # while true + 844 # if line->read >= line->write 845 # break - 846 # if line->data[line->read] == ')' + 846 # if line->data[line->read] == ' ' 847 # break - 848 # if line->data[line->read] == '/' - 849 # abort - 850 # ++line->read - 851 # out->end = &line->data[line->read] - 852 # - 853 # registers: - 854 # ecx: often line->read - 855 # eax: often line->data[line->read] - 856 # - 857 # . prologue - 858 55/push-ebp - 859 89/<- %ebp 4/r32/esp - 860 # . save registers - 861 50/push-eax - 862 51/push-ecx - 863 56/push-esi - 864 57/push-edi - 865 # esi = line - 866 8b/-> *(ebp+8) 6/r32/esi - 867 # edi = out - 868 8b/-> *(ebp+0xc) 7/r32/edi - 869 # skip-chars-matching(line, ' ') - 870 # . . push args - 871 68/push 0x20/imm32/space - 872 ff 6/subop/push *(ebp+8) - 873 # . . call - 874 e8/call skip-chars-matching/disp32 - 875 # . . discard args - 876 81 0/subop/add %esp 8/imm32 - 877 $next-word-string-or-expression-without-metadata:check0: - 878 # if (line->read >= line->write) abort because we didn't encounter a final ')' - 879 # . ecx = line->read - 880 8b/-> *(esi+4) 1/r32/ecx - 881 # . if (ecx >= line->write) abort - 882 3b/compare<- *esi 1/r32/ecx - 883 0f 8d/jump-if->= $next-word-string-or-expression-without-metadata:error0/disp32 - 884 $next-word-string-or-expression-without-metadata:check-for-comment: - 885 # out->start = &line->data[line->read] - 886 8d/copy-address *(esi+ecx+0xc) 0/r32/eax - 887 89/<- *edi 0/r32/eax - 888 # if (line->data[line->read] != '#') goto next check - 889 # . var eax: byte = line->data[line->read] - 890 31/xor-with %eax 0/r32/eax - 891 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL - 892 # . if (eax != '#') goto next check - 893 3d/compare-eax-and 0x23/imm32/pound - 894 75/jump-if-!= $next-word-string-or-expression-without-metadata:check-for-string-literal/disp8 - 895 $next-word-string-or-expression-without-metadata:comment: - 896 # out->end = &line->data[line->write] - 897 8b/-> *esi 0/r32/eax - 898 8d/copy-address *(esi+eax+0xc) 0/r32/eax - 899 89/<- *(edi+4) 0/r32/eax - 900 # line->read = line->write # skip rest of line - 901 8b/-> *esi 0/r32/eax - 902 89/<- *(esi+4) 0/r32/eax - 903 # return - 904 e9/jump $next-word-string-or-expression-without-metadata:end/disp32 - 905 $next-word-string-or-expression-without-metadata:check-for-string-literal: - 906 # if (line->data[line->read] != '"') goto next check - 907 3d/compare-eax-and 0x22/imm32/dquote - 908 75/jump-if-!= $next-word-string-or-expression-without-metadata:check-for-expression/disp8 - 909 $next-word-string-or-expression-without-metadata:string-literal: - 910 # skip-string(line) - 911 # . . push args - 912 56/push-esi - 913 # . . call - 914 e8/call skip-string/disp32 - 915 # . . discard args - 916 81 0/subop/add %esp 4/imm32 - 917 # out->end = &line->data[line->read] - 918 8b/-> *(esi+4) 1/r32/ecx - 919 8d/copy-address *(esi+ecx+0xc) 0/r32/eax - 920 89/<- *(edi+4) 0/r32/eax - 921 # return - 922 e9/jump $next-word-string-or-expression-without-metadata:end/disp32 - 923 $next-word-string-or-expression-without-metadata:check-for-expression: - 924 # if (line->data[line->read] != '*') goto next check - 925 3d/compare-eax-and 0x2a/imm32/asterisk - 926 75/jump-if-!= $next-word-string-or-expression-without-metadata:check-for-end-of-call/disp8 - 927 # if (line->data[line->read + 1] == ' ') goto error1 - 928 8a/copy-byte *(esi+ecx+0xd) 0/r32/AL - 929 3d/compare-eax-and 0x20/imm32/space - 930 0f 84/jump-if-= $next-word-string-or-expression-without-metadata:error1/disp32 - 931 # if (line->data[line->read + 1] != '(') goto regular-word - 932 3d/compare-eax-and 0x28/imm32/open-paren - 933 0f 85/jump-if-!= $next-word-string-or-expression-without-metadata:regular-word-without-metadata/disp32 - 934 $next-word-string-or-expression-without-metadata:paren: - 935 # skip-until-close-paren(line) - 936 # . . push args - 937 56/push-esi - 938 # . . call - 939 e8/call skip-until-close-paren/disp32 - 940 # . . discard args - 941 81 0/subop/add %esp 4/imm32 - 942 # if (line->data[line->read] != ')') goto error2 - 943 # . eax = line->data[line->read] - 944 8b/-> *(esi+4) 1/r32/ecx - 945 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL - 946 # . if (eax != ')') goto error2 - 947 3d/compare-eax-and 0x29/imm32/close-paren - 948 0f 85/jump-if-!= $next-word-string-or-expression-without-metadata:error2/disp32 - 949 # ++line->read to skip ')' - 950 ff 0/subop/increment *(esi+4) - 951 # out->end = &line->data[line->read] - 952 8b/-> *(esi+4) 1/r32/ecx - 953 8d/copy-address *(esi+ecx+0xc) 0/r32/eax - 954 89/<- *(edi+4) 0/r32/eax - 955 # return - 956 e9/jump $next-word-string-or-expression-without-metadata:end/disp32 - 957 $next-word-string-or-expression-without-metadata:check-for-end-of-call: - 958 # if (line->data[line->read] != ')') goto next check - 959 3d/compare-eax-and 0x29/imm32/close-paren - 960 75/jump-if-!= $next-word-string-or-expression-without-metadata:regular-word-without-metadata/disp8 - 961 # ++line->read to skip ')' - 962 ff 0/subop/increment *(esi+4) - 963 # - error checking: make sure there's nothing else of importance on the line - 964 # if (line->read >= line->write) return out = {0, 0} - 965 # . ecx = line->read - 966 8b/-> *(esi+4) 1/r32/ecx - 967 # . if (ecx >= line->write) return {0, 0} - 968 3b/compare<- *esi 1/r32/ecx - 969 0f 8d/jump-if->= $next-word-string-or-expression-without-metadata:return-eol/disp32 - 970 # if (line->data[line->read] == '/') goto error3 - 971 # . eax = line->data[line->read] - 972 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL - 973 # . if (eax == '/') goto error3 - 974 3d/compare-eax-and 0x2f/imm32/slash - 975 0f 84/jump-if-= $next-word-string-or-expression-without-metadata:error3/disp32 - 976 # skip-chars-matching-whitespace(line) - 977 # . . push args - 978 56/push-esi - 979 # . . call - 980 e8/call skip-chars-matching-whitespace/disp32 - 981 # . . discard args - 982 81 0/subop/add %esp 4/imm32 - 983 # if (line->read >= line->write) return out = {0, 0} - 984 # . ecx = line->read - 985 8b/-> *(esi+4) 1/r32/ecx - 986 # . if (ecx >= line->write) return {0, 0} - 987 3b/compare<- *esi 1/r32/ecx - 988 0f 8d/jump-if->= $next-word-string-or-expression-without-metadata:return-eol/disp32 - 989 # if (line->data[line->read] == '#') return out = {0, 0} - 990 # . eax = line->data[line->read] + 848 # if line->data[line->read] == ')' + 849 # break + 850 # if line->data[line->read] == '/' + 851 # abort + 852 # ++line->read + 853 # out->end = &line->data[line->read] + 854 # + 855 # registers: + 856 # ecx: often line->read + 857 # eax: often line->data[line->read] + 858 # + 859 # . prologue + 860 55/push-ebp + 861 89/<- %ebp 4/r32/esp + 862 # . save registers + 863 50/push-eax + 864 51/push-ecx + 865 56/push-esi + 866 57/push-edi + 867 # esi = line + 868 8b/-> *(ebp+8) 6/r32/esi + 869 # edi = out + 870 8b/-> *(ebp+0xc) 7/r32/edi + 871 # skip-chars-matching(line, ' ') + 872 # . . push args + 873 68/push 0x20/imm32/space + 874 ff 6/subop/push *(ebp+8) + 875 # . . call + 876 e8/call skip-chars-matching/disp32 + 877 # . . discard args + 878 81 0/subop/add %esp 8/imm32 + 879 $next-word-string-or-expression-without-metadata:check0: + 880 # if (line->read >= line->write) abort because we didn't encounter a final ')' + 881 # . ecx = line->read + 882 8b/-> *(esi+4) 1/r32/ecx + 883 # . if (ecx >= line->write) abort + 884 3b/compare<- *esi 1/r32/ecx + 885 0f 8d/jump-if->= $next-word-string-or-expression-without-metadata:error0/disp32 + 886 $next-word-string-or-expression-without-metadata:check-for-comment: + 887 # out->start = &line->data[line->read] + 888 8d/copy-address *(esi+ecx+0xc) 0/r32/eax + 889 89/<- *edi 0/r32/eax + 890 # if (line->data[line->read] != '#') goto next check + 891 # . var eax: byte = line->data[line->read] + 892 31/xor-with %eax 0/r32/eax + 893 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL + 894 # . if (eax != '#') goto next check + 895 3d/compare-eax-and 0x23/imm32/pound + 896 75/jump-if-!= $next-word-string-or-expression-without-metadata:check-for-string-literal/disp8 + 897 $next-word-string-or-expression-without-metadata:comment: + 898 # out->end = &line->data[line->write] + 899 8b/-> *esi 0/r32/eax + 900 8d/copy-address *(esi+eax+0xc) 0/r32/eax + 901 89/<- *(edi+4) 0/r32/eax + 902 # line->read = line->write # skip rest of line + 903 8b/-> *esi 0/r32/eax + 904 89/<- *(esi+4) 0/r32/eax + 905 # return + 906 e9/jump $next-word-string-or-expression-without-metadata:end/disp32 + 907 $next-word-string-or-expression-without-metadata:check-for-string-literal: + 908 # if (line->data[line->read] != '"') goto next check + 909 3d/compare-eax-and 0x22/imm32/dquote + 910 75/jump-if-!= $next-word-string-or-expression-without-metadata:check-for-expression/disp8 + 911 $next-word-string-or-expression-without-metadata:string-literal: + 912 # skip-string(line) + 913 # . . push args + 914 56/push-esi + 915 # . . call + 916 e8/call skip-string/disp32 + 917 # . . discard args + 918 81 0/subop/add %esp 4/imm32 + 919 # out->end = &line->data[line->read] + 920 8b/-> *(esi+4) 1/r32/ecx + 921 8d/copy-address *(esi+ecx+0xc) 0/r32/eax + 922 89/<- *(edi+4) 0/r32/eax + 923 # return + 924 e9/jump $next-word-string-or-expression-without-metadata:end/disp32 + 925 $next-word-string-or-expression-without-metadata:check-for-expression: + 926 # if (line->data[line->read] != '*') goto next check + 927 3d/compare-eax-and 0x2a/imm32/asterisk + 928 75/jump-if-!= $next-word-string-or-expression-without-metadata:check-for-open-paren/disp8 + 929 # if (line->data[line->read + 1] == ' ') goto error1 + 930 8a/copy-byte *(esi+ecx+0xd) 0/r32/AL + 931 3d/compare-eax-and 0x20/imm32/space + 932 0f 84/jump-if-= $next-word-string-or-expression-without-metadata:error1/disp32 + 933 # if (line->data[line->read + 1] != '(') goto regular-word + 934 3d/compare-eax-and 0x28/imm32/open-paren + 935 0f 85/jump-if-!= $next-word-string-or-expression-without-metadata:regular-word-without-metadata/disp32 + 936 $next-word-string-or-expression-without-metadata:paren: + 937 # skip-until-close-paren(line) + 938 # . . push args + 939 56/push-esi + 940 # . . call + 941 e8/call skip-until-close-paren/disp32 + 942 # . . discard args + 943 81 0/subop/add %esp 4/imm32 + 944 # if (line->data[line->read] != ')') goto error2 + 945 # . eax = line->data[line->read] + 946 8b/-> *(esi+4) 1/r32/ecx + 947 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL + 948 # . if (eax != ')') goto error2 + 949 3d/compare-eax-and 0x29/imm32/close-paren + 950 0f 85/jump-if-!= $next-word-string-or-expression-without-metadata:error2/disp32 + 951 # ++line->read to skip ')' + 952 ff 0/subop/increment *(esi+4) + 953 # out->end = &line->data[line->read] + 954 8b/-> *(esi+4) 1/r32/ecx + 955 8d/copy-address *(esi+ecx+0xc) 0/r32/eax + 956 89/<- *(edi+4) 0/r32/eax + 957 # return + 958 e9/jump $next-word-string-or-expression-without-metadata:end/disp32 + 959 $next-word-string-or-expression-without-metadata:check-for-open-paren: + 960 # if (line->data[line->read] == '(') abort + 961 3d/compare-eax-and 0x28/imm32/open-paren + 962 0f 84/jump-if-= $next-word-string-or-expression-without-metadata:error4a/disp32 + 963 $next-word-string-or-expression-without-metadata:check-for-end-of-call: + 964 # if (line->data[line->read] != ')') goto next check + 965 3d/compare-eax-and 0x29/imm32/close-paren + 966 75/jump-if-!= $next-word-string-or-expression-without-metadata:regular-word-without-metadata/disp8 + 967 # ++line->read to skip ')' + 968 ff 0/subop/increment *(esi+4) + 969 # - error checking: make sure there's nothing else of importance on the line + 970 # if (line->read >= line->write) return out = {0, 0} + 971 # . ecx = line->read + 972 8b/-> *(esi+4) 1/r32/ecx + 973 # . if (ecx >= line->write) return {0, 0} + 974 3b/compare<- *esi 1/r32/ecx + 975 0f 8d/jump-if->= $next-word-string-or-expression-without-metadata:return-eol/disp32 + 976 # if (line->data[line->read] == '/') goto error3 + 977 # . eax = line->data[line->read] + 978 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL + 979 # . if (eax == '/') goto error3 + 980 3d/compare-eax-and 0x2f/imm32/slash + 981 0f 84/jump-if-= $next-word-string-or-expression-without-metadata:error3/disp32 + 982 # skip-chars-matching-whitespace(line) + 983 # . . push args + 984 56/push-esi + 985 # . . call + 986 e8/call skip-chars-matching-whitespace/disp32 + 987 # . . discard args + 988 81 0/subop/add %esp 4/imm32 + 989 # if (line->read >= line->write) return out = {0, 0} + 990 # . ecx = line->read 991 8b/-> *(esi+4) 1/r32/ecx - 992 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL - 993 # . if (eax == '#') return out = {0, 0} - 994 3d/compare-eax-and 0x23/imm32/pound - 995 74/jump-if-= $next-word-string-or-expression-without-metadata:return-eol/disp8 - 996 # otherwise goto error4 - 997 e9/jump $next-word-string-or-expression-without-metadata:error4/disp32 - 998 $next-word-string-or-expression-without-metadata:regular-word-without-metadata: - 999 # if (line->read >= line->write) break -1000 # . ecx = line->read -1001 8b/-> *(esi+4) 1/r32/ecx -1002 # . if (ecx >= line->write) break -1003 3b/compare<- *esi 1/r32/ecx -1004 7d/jump-if->= $next-word-string-or-expression-without-metadata:regular-word-break/disp8 -1005 # if (line->data[line->read] == ' ') break -1006 # . eax = line->data[line->read] + 992 # . if (ecx >= line->write) return {0, 0} + 993 3b/compare<- *esi 1/r32/ecx + 994 0f 8d/jump-if->= $next-word-string-or-expression-without-metadata:return-eol/disp32 + 995 # if (line->data[line->read] == '#') return out = {0, 0} + 996 # . eax = line->data[line->read] + 997 8b/-> *(esi+4) 1/r32/ecx + 998 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL + 999 # . if (eax == '#') return out = {0, 0} +1000 3d/compare-eax-and 0x23/imm32/pound +1001 74/jump-if-= $next-word-string-or-expression-without-metadata:return-eol/disp8 +1002 # otherwise goto error4 +1003 e9/jump $next-word-string-or-expression-without-metadata:error4/disp32 +1004 $next-word-string-or-expression-without-metadata:regular-word-without-metadata: +1005 # if (line->read >= line->write) break +1006 # . ecx = line->read 1007 8b/-> *(esi+4) 1/r32/ecx -1008 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL -1009 # . if (eax == ' ') break -1010 3d/compare-eax-and 0x20/imm32/space -1011 74/jump-if-= $next-word-string-or-expression-without-metadata:regular-word-break/disp8 -1012 # if (line->data[line->read] == ')') break -1013 3d/compare-eax-and 0x29/imm32/close-paren -1014 0f 84/jump-if-= $next-word-string-or-expression-without-metadata:regular-word-break/disp32 -1015 # if (line->data[line->read] == '/') goto error5 -1016 3d/compare-eax-and 0x2f/imm32/slash -1017 0f 84/jump-if-= $next-word-string-or-expression-without-metadata:error5/disp32 -1018 # ++line->read -1019 ff 0/subop/increment *(esi+4) -1020 # loop -1021 e9/jump $next-word-string-or-expression-without-metadata:regular-word-without-metadata/disp32 -1022 $next-word-string-or-expression-without-metadata:regular-word-break: -1023 # out->end = &line->data[line->read] -1024 8b/-> *(esi+4) 1/r32/ecx -1025 8d/copy-address *(esi+ecx+0xc) 0/r32/eax -1026 89/<- *(edi+4) 0/r32/eax -1027 eb/jump $next-word-string-or-expression-without-metadata:end/disp8 -1028 $next-word-string-or-expression-without-metadata:return-eol: -1029 # return out = {0, 0} -1030 c7 0/subop/copy *edi 0/imm32 -1031 c7 0/subop/copy *(edi+4) 0/imm32 -1032 $next-word-string-or-expression-without-metadata:end: -1033 # . restore registers -1034 5f/pop-to-edi -1035 5e/pop-to-esi -1036 59/pop-to-ecx -1037 58/pop-to-eax -1038 # . epilogue -1039 89/<- %esp 5/r32/ebp -1040 5d/pop-to-ebp -1041 c3/return -1042 -1043 $next-word-string-or-expression-without-metadata:error0: -1044 # print(stderr, "error: missing final ')' in '" line "'") -1045 # . write-buffered(Stderr, "error: missing final ')' in '") -1046 # . . push args -1047 68/push "error: missing final ')' in '"/imm32 -1048 68/push Stderr/imm32 -1049 # . . call -1050 e8/call write-buffered/disp32 -1051 # . . discard args -1052 81 0/subop/add %esp 8/imm32 -1053 # . write-stream-data(Stderr, line) -1054 # . . push args -1055 56/push-esi -1056 68/push Stderr/imm32 -1057 # . . call -1058 e8/call write-stream-data/disp32 -1059 # . . discard args -1060 81 0/subop/add %esp 8/imm32 -1061 # . write-buffered(Stderr, "'") -1062 # . . push args -1063 68/push "'"/imm32 -1064 68/push Stderr/imm32 -1065 # . . call -1066 e8/call write-buffered/disp32 -1067 # . . discard args -1068 81 0/subop/add %esp 8/imm32 -1069 # . flush(Stderr) -1070 # . . push args -1071 68/push Stderr/imm32 -1072 # . . call -1073 e8/call flush/disp32 -1074 # . . discard args -1075 81 0/subop/add %esp 4/imm32 -1076 # . syscall(exit, 1) -1077 bb/copy-to-ebx 1/imm32 -1078 e8/call syscall_exit/disp32 -1079 # never gets here -1080 -1081 $next-word-string-or-expression-without-metadata:error1: -1082 # print(stderr, "error: no space allowed after '*' in '" line "'") -1083 # . write-buffered(Stderr, "error: no space allowed after '*' in '") -1084 # . . push args -1085 68/push "error: no space allowed after '*' in '"/imm32 -1086 68/push Stderr/imm32 -1087 # . . call -1088 e8/call write-buffered/disp32 -1089 # . . discard args -1090 81 0/subop/add %esp 8/imm32 -1091 # . write-stream-data(Stderr, line) -1092 # . . push args -1093 56/push-esi -1094 68/push Stderr/imm32 -1095 # . . call -1096 e8/call write-stream-data/disp32 -1097 # . . discard args -1098 81 0/subop/add %esp 8/imm32 -1099 # . write-buffered(Stderr, "'") -1100 # . . push args -1101 68/push "'"/imm32 -1102 68/push Stderr/imm32 -1103 # . . call -1104 e8/call write-buffered/disp32 -1105 # . . discard args -1106 81 0/subop/add %esp 8/imm32 -1107 # . flush(Stderr) -1108 # . . push args -1109 68/push Stderr/imm32 -1110 # . . call -1111 e8/call flush/disp32 -1112 # . . discard args -1113 81 0/subop/add %esp 4/imm32 -1114 # . syscall(exit, 1) -1115 bb/copy-to-ebx 1/imm32 -1116 e8/call syscall_exit/disp32 -1117 # never gets here -1118 -1119 $next-word-string-or-expression-without-metadata:error2: -1120 # print(stderr, "error: *(...) expression must be all on a single line in '" line "'") -1121 # . write-buffered(Stderr, "error: *(...) expression must be all on a single line in '") -1122 # . . push args -1123 68/push "error: *(...) expression must be all on a single line in '"/imm32 -1124 68/push Stderr/imm32 -1125 # . . call -1126 e8/call write-buffered/disp32 -1127 # . . discard args -1128 81 0/subop/add %esp 8/imm32 -1129 # . write-stream-data(Stderr, line) -1130 # . . push args -1131 56/push-esi -1132 68/push Stderr/imm32 -1133 # . . call -1134 e8/call write-stream-data/disp32 -1135 # . . discard args -1136 81 0/subop/add %esp 8/imm32 -1137 # . write-buffered(Stderr, "'") -1138 # . . push args -1139 68/push "'"/imm32 -1140 68/push Stderr/imm32 -1141 # . . call -1142 e8/call write-buffered/disp32 -1143 # . . discard args -1144 81 0/subop/add %esp 8/imm32 -1145 # . flush(Stderr) -1146 # . . push args -1147 68/push Stderr/imm32 -1148 # . . call -1149 e8/call flush/disp32 -1150 # . . discard args -1151 81 0/subop/add %esp 4/imm32 -1152 # . syscall(exit, 1) -1153 bb/copy-to-ebx 1/imm32 -1154 e8/call syscall_exit/disp32 -1155 # never gets here -1156 -1157 $next-word-string-or-expression-without-metadata:error3: -1158 # print(stderr, "error: no metadata after calls; just use a comment (in '" line "')") -1159 # . write-buffered(Stderr, "error: no metadata after calls; just use a comment (in '") -1160 # . . push args -1161 68/push "error: no metadata after calls; just use a comment (in '"/imm32 -1162 68/push Stderr/imm32 -1163 # . . call -1164 e8/call write-buffered/disp32 -1165 # . . discard args -1166 81 0/subop/add %esp 8/imm32 -1167 # . write-stream-data(Stderr, line) -1168 # . . push args -1169 56/push-esi -1170 68/push Stderr/imm32 -1171 # . . call -1172 e8/call write-stream-data/disp32 -1173 # . . discard args -1174 81 0/subop/add %esp 8/imm32 -1175 # . write-buffered(Stderr, "')") -1176 # . . push args -1177 68/push "')"/imm32 -1178 68/push Stderr/imm32 -1179 # . . call -1180 e8/call write-buffered/disp32 -1181 # . . discard args -1182 81 0/subop/add %esp 8/imm32 -1183 # . flush(Stderr) -1184 # . . push args -1185 68/push Stderr/imm32 -1186 # . . call -1187 e8/call flush/disp32 -1188 # . . discard args -1189 81 0/subop/add %esp 4/imm32 -1190 # . syscall(exit, 1) -1191 bb/copy-to-ebx 1/imm32 -1192 e8/call syscall_exit/disp32 -1193 # never gets here -1194 -1195 $next-word-string-or-expression-without-metadata:error4: -1196 # print(stderr, "error: unexpected text after end of call in '" line "'") -1197 # . write-buffered(Stderr, "error: unexpected text after end of call in '") -1198 # . . push args -1199 68/push "error: unexpected text after end of call in '"/imm32 -1200 68/push Stderr/imm32 -1201 # . . call -1202 e8/call write-buffered/disp32 -1203 # . . discard args -1204 81 0/subop/add %esp 8/imm32 -1205 # . write-stream-data(Stderr, line) -1206 # . . push args -1207 56/push-esi -1208 68/push Stderr/imm32 -1209 # . . call -1210 e8/call write-stream-data/disp32 -1211 # . . discard args -1212 81 0/subop/add %esp 8/imm32 -1213 # . write-buffered(Stderr, "'") -1214 # . . push args -1215 68/push "'"/imm32 -1216 68/push Stderr/imm32 -1217 # . . call -1218 e8/call write-buffered/disp32 -1219 # . . discard args -1220 81 0/subop/add %esp 8/imm32 -1221 # . flush(Stderr) -1222 # . . push args -1223 68/push Stderr/imm32 -1224 # . . call -1225 e8/call flush/disp32 -1226 # . . discard args -1227 81 0/subop/add %esp 4/imm32 -1228 # . syscall(exit, 1) -1229 bb/copy-to-ebx 1/imm32 -1230 e8/call syscall_exit/disp32 -1231 # never gets here -1232 -1233 $next-word-string-or-expression-without-metadata:error5: -1234 # print(stderr, "error: no metadata anywhere in calls (in '" line "')") -1235 # . write-buffered(Stderr, "error: no metadata anywhere in calls (in '") -1236 # . . push args -1237 68/push "error: no metadata anywhere in calls (in '"/imm32 -1238 68/push Stderr/imm32 -1239 # . . call -1240 e8/call write-buffered/disp32 -1241 # . . discard args -1242 81 0/subop/add %esp 8/imm32 -1243 # . write-stream-data(Stderr, line) -1244 # . . push args -1245 56/push-esi -1246 68/push Stderr/imm32 -1247 # . . call -1248 e8/call write-stream-data/disp32 -1249 # . . discard args -1250 81 0/subop/add %esp 8/imm32 -1251 # . write-buffered(Stderr, "')") -1252 # . . push args -1253 68/push "')"/imm32 -1254 68/push Stderr/imm32 -1255 # . . call -1256 e8/call write-buffered/disp32 -1257 # . . discard args -1258 81 0/subop/add %esp 8/imm32 -1259 # . flush(Stderr) -1260 # . . push args -1261 68/push Stderr/imm32 -1262 # . . call -1263 e8/call flush/disp32 -1264 # . . discard args -1265 81 0/subop/add %esp 4/imm32 -1266 # . syscall(exit, 1) -1267 bb/copy-to-ebx 1/imm32 -1268 e8/call syscall_exit/disp32 -1269 # never gets here -1270 -1271 test-next-word-string-or-expression-without-metadata: -1272 # . prologue -1273 55/push-ebp -1274 89/<- %ebp 4/r32/esp -1275 # setup -1276 # . clear-stream(_test-input-stream) -1277 # . . push args -1278 68/push _test-input-stream/imm32 -1279 # . . call -1280 e8/call clear-stream/disp32 -1281 # . . discard args -1282 81 0/subop/add %esp 4/imm32 -1283 # var slice/ecx: slice -1284 68/push 0/imm32/end -1285 68/push 0/imm32/start -1286 89/<- %ecx 4/r32/esp -1287 # write(_test-input-stream, " ab") +1008 # . if (ecx >= line->write) break +1009 3b/compare<- *esi 1/r32/ecx +1010 7d/jump-if->= $next-word-string-or-expression-without-metadata:regular-word-break/disp8 +1011 # if (line->data[line->read] == ' ') break +1012 # . eax = line->data[line->read] +1013 8b/-> *(esi+4) 1/r32/ecx +1014 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL +1015 # . if (eax == ' ') break +1016 3d/compare-eax-and 0x20/imm32/space +1017 74/jump-if-= $next-word-string-or-expression-without-metadata:regular-word-break/disp8 +1018 # if (line->data[line->read] == ')') break +1019 3d/compare-eax-and 0x29/imm32/close-paren +1020 0f 84/jump-if-= $next-word-string-or-expression-without-metadata:regular-word-break/disp32 +1021 # if (line->data[line->read] == '/') goto error5 +1022 3d/compare-eax-and 0x2f/imm32/slash +1023 0f 84/jump-if-= $next-word-string-or-expression-without-metadata:error5/disp32 +1024 # ++line->read +1025 ff 0/subop/increment *(esi+4) +1026 # loop +1027 e9/jump $next-word-string-or-expression-without-metadata:regular-word-without-metadata/disp32 +1028 $next-word-string-or-expression-without-metadata:regular-word-break: +1029 # out->end = &line->data[line->read] +1030 8b/-> *(esi+4) 1/r32/ecx +1031 8d/copy-address *(esi+ecx+0xc) 0/r32/eax +1032 89/<- *(edi+4) 0/r32/eax +1033 eb/jump $next-word-string-or-expression-without-metadata:end/disp8 +1034 $next-word-string-or-expression-without-metadata:return-eol: +1035 # return out = {0, 0} +1036 c7 0/subop/copy *edi 0/imm32 +1037 c7 0/subop/copy *(edi+4) 0/imm32 +1038 $next-word-string-or-expression-without-metadata:end: +1039 # . restore registers +1040 5f/pop-to-edi +1041 5e/pop-to-esi +1042 59/pop-to-ecx +1043 58/pop-to-eax +1044 # . epilogue +1045 89/<- %esp 5/r32/ebp +1046 5d/pop-to-ebp +1047 c3/return +1048 +1049 $next-word-string-or-expression-without-metadata:error0: +1050 # print(stderr, "error: missing final ')' in '" line "'") +1051 # . write-buffered(Stderr, "error: missing final ')' in '") +1052 # . . push args +1053 68/push "error: missing final ')' in '"/imm32 +1054 68/push Stderr/imm32 +1055 # . . call +1056 e8/call write-buffered/disp32 +1057 # . . discard args +1058 81 0/subop/add %esp 8/imm32 +1059 # . write-stream-data(Stderr, line) +1060 # . . push args +1061 56/push-esi +1062 68/push Stderr/imm32 +1063 # . . call +1064 e8/call write-stream-data/disp32 +1065 # . . discard args +1066 81 0/subop/add %esp 8/imm32 +1067 # . write-buffered(Stderr, "'") +1068 # . . push args +1069 68/push "'"/imm32 +1070 68/push Stderr/imm32 +1071 # . . call +1072 e8/call write-buffered/disp32 +1073 # . . discard args +1074 81 0/subop/add %esp 8/imm32 +1075 # . flush(Stderr) +1076 # . . push args +1077 68/push Stderr/imm32 +1078 # . . call +1079 e8/call flush/disp32 +1080 # . . discard args +1081 81 0/subop/add %esp 4/imm32 +1082 # . syscall(exit, 1) +1083 bb/copy-to-ebx 1/imm32 +1084 e8/call syscall_exit/disp32 +1085 # never gets here +1086 +1087 $next-word-string-or-expression-without-metadata:error1: +1088 # print(stderr, "error: no space allowed after '*' in '" line "'") +1089 # . write-buffered(Stderr, "error: no space allowed after '*' in '") +1090 # . . push args +1091 68/push "error: no space allowed after '*' in '"/imm32 +1092 68/push Stderr/imm32 +1093 # . . call +1094 e8/call write-buffered/disp32 +1095 # . . discard args +1096 81 0/subop/add %esp 8/imm32 +1097 # . write-stream-data(Stderr, line) +1098 # . . push args +1099 56/push-esi +1100 68/push Stderr/imm32 +1101 # . . call +1102 e8/call write-stream-data/disp32 +1103 # . . discard args +1104 81 0/subop/add %esp 8/imm32 +1105 # . write-buffered(Stderr, "'") +1106 # . . push args +1107 68/push "'"/imm32 +1108 68/push Stderr/imm32 +1109 # . . call +1110 e8/call write-buffered/disp32 +1111 # . . discard args +1112 81 0/subop/add %esp 8/imm32 +1113 # . flush(Stderr) +1114 # . . push args +1115 68/push Stderr/imm32 +1116 # . . call +1117 e8/call flush/disp32 +1118 # . . discard args +1119 81 0/subop/add %esp 4/imm32 +1120 # . syscall(exit, 1) +1121 bb/copy-to-ebx 1/imm32 +1122 e8/call syscall_exit/disp32 +1123 # never gets here +1124 +1125 $next-word-string-or-expression-without-metadata:error2: +1126 # print(stderr, "error: *(...) expression must be all on a single line in '" line "'") +1127 # . write-buffered(Stderr, "error: *(...) expression must be all on a single line in '") +1128 # . . push args +1129 68/push "error: *(...) expression must be all on a single line in '"/imm32 +1130 68/push Stderr/imm32 +1131 # . . call +1132 e8/call write-buffered/disp32 +1133 # . . discard args +1134 81 0/subop/add %esp 8/imm32 +1135 # . write-stream-data(Stderr, line) +1136 # . . push args +1137 56/push-esi +1138 68/push Stderr/imm32 +1139 # . . call +1140 e8/call write-stream-data/disp32 +1141 # . . discard args +1142 81 0/subop/add %esp 8/imm32 +1143 # . write-buffered(Stderr, "'") +1144 # . . push args +1145 68/push "'"/imm32 +1146 68/push Stderr/imm32 +1147 # . . call +1148 e8/call write-buffered/disp32 +1149 # . . discard args +1150 81 0/subop/add %esp 8/imm32 +1151 # . flush(Stderr) +1152 # . . push args +1153 68/push Stderr/imm32 +1154 # . . call +1155 e8/call flush/disp32 +1156 # . . discard args +1157 81 0/subop/add %esp 4/imm32 +1158 # . syscall(exit, 1) +1159 bb/copy-to-ebx 1/imm32 +1160 e8/call syscall_exit/disp32 +1161 # never gets here +1162 +1163 $next-word-string-or-expression-without-metadata:error3: +1164 # print(stderr, "error: no metadata after calls; just use a comment (in '" line "')") +1165 # . write-buffered(Stderr, "error: no metadata after calls; just use a comment (in '") +1166 # . . push args +1167 68/push "error: no metadata after calls; just use a comment (in '"/imm32 +1168 68/push Stderr/imm32 +1169 # . . call +1170 e8/call write-buffered/disp32 +1171 # . . discard args +1172 81 0/subop/add %esp 8/imm32 +1173 # . write-stream-data(Stderr, line) +1174 # . . push args +1175 56/push-esi +1176 68/push Stderr/imm32 +1177 # . . call +1178 e8/call write-stream-data/disp32 +1179 # . . discard args +1180 81 0/subop/add %esp 8/imm32 +1181 # . write-buffered(Stderr, "')") +1182 # . . push args +1183 68/push "')"/imm32 +1184 68/push Stderr/imm32 +1185 # . . call +1186 e8/call write-buffered/disp32 +1187 # . . discard args +1188 81 0/subop/add %esp 8/imm32 +1189 # . flush(Stderr) +1190 # . . push args +1191 68/push Stderr/imm32 +1192 # . . call +1193 e8/call flush/disp32 +1194 # . . discard args +1195 81 0/subop/add %esp 4/imm32 +1196 # . syscall(exit, 1) +1197 bb/copy-to-ebx 1/imm32 +1198 e8/call syscall_exit/disp32 +1199 # never gets here +1200 +1201 $next-word-string-or-expression-without-metadata:error4a: +1202 # print(stderr, "error: unexpected '(' within call in '" line "'") +1203 # . write-buffered(Stderr, "error: unexpected '(' within call in '") +1204 # . . push args +1205 68/push "error: unexpected '(' within call in '"/imm32 +1206 68/push Stderr/imm32 +1207 # . . call +1208 e8/call write-buffered/disp32 +1209 # . . discard args +1210 81 0/subop/add %esp 8/imm32 +1211 # . write-stream-data(Stderr, line) +1212 # . . push args +1213 56/push-esi +1214 68/push Stderr/imm32 +1215 # . . call +1216 e8/call write-stream-data/disp32 +1217 # . . discard args +1218 81 0/subop/add %esp 8/imm32 +1219 # . write-buffered(Stderr, "'\n") +1220 # . . push args +1221 68/push "'\n"/imm32 +1222 68/push Stderr/imm32 +1223 # . . call +1224 e8/call write-buffered/disp32 +1225 # . . discard args +1226 81 0/subop/add %esp 8/imm32 +1227 # . flush(Stderr) +1228 # . . push args +1229 68/push Stderr/imm32 +1230 # . . call +1231 e8/call flush/disp32 +1232 # . . discard args +1233 81 0/subop/add %esp 4/imm32 +1234 # . syscall(exit, 1) +1235 bb/copy-to-ebx 1/imm32 +1236 e8/call syscall_exit/disp32 +1237 # never gets here +1238 +1239 $next-word-string-or-expression-without-metadata:error4: +1240 # print(stderr, "error: unexpected text after end of call in '" line "'") +1241 # . write-buffered(Stderr, "error: unexpected text after end of call in '") +1242 # . . push args +1243 68/push "error: unexpected text after end of call in '"/imm32 +1244 68/push Stderr/imm32 +1245 # . . call +1246 e8/call write-buffered/disp32 +1247 # . . discard args +1248 81 0/subop/add %esp 8/imm32 +1249 # . write-stream-data(Stderr, line) +1250 # . . push args +1251 56/push-esi +1252 68/push Stderr/imm32 +1253 # . . call +1254 e8/call write-stream-data/disp32 +1255 # . . discard args +1256 81 0/subop/add %esp 8/imm32 +1257 # . write-buffered(Stderr, "'") +1258 # . . push args +1259 68/push "'"/imm32 +1260 68/push Stderr/imm32 +1261 # . . call +1262 e8/call write-buffered/disp32 +1263 # . . discard args +1264 81 0/subop/add %esp 8/imm32 +1265 # . flush(Stderr) +1266 # . . push args +1267 68/push Stderr/imm32 +1268 # . . call +1269 e8/call flush/disp32 +1270 # . . discard args +1271 81 0/subop/add %esp 4/imm32 +1272 # . syscall(exit, 1) +1273 bb/copy-to-ebx 1/imm32 +1274 e8/call syscall_exit/disp32 +1275 # never gets here +1276 +1277 $next-word-string-or-expression-without-metadata:error5: +1278 # print(stderr, "error: no metadata anywhere in calls (in '" line "')") +1279 # . write-buffered(Stderr, "error: no metadata anywhere in calls (in '") +1280 # . . push args +1281 68/push "error: no metadata anywhere in calls (in '"/imm32 +1282 68/push Stderr/imm32 +1283 # . . call +1284 e8/call write-buffered/disp32 +1285 # . . discard args +1286 81 0/subop/add %esp 8/imm32 +1287 # . write-stream-data(Stderr, line) 1288 # . . push args -1289 68/push " ab"/imm32 -1290 68/push _test-input-stream/imm32 +1289 56/push-esi +1290 68/push Stderr/imm32 1291 # . . call -1292 e8/call write/disp32 +1292 e8/call write-stream-data/disp32 1293 # . . discard args 1294 81 0/subop/add %esp 8/imm32 -1295 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) +1295 # . write-buffered(Stderr, "')") 1296 # . . push args -1297 51/push-ecx -1298 68/push _test-input-stream/imm32 +1297 68/push "')"/imm32 +1298 68/push Stderr/imm32 1299 # . . call -1300 e8/call next-word-string-or-expression-without-metadata/disp32 +1300 e8/call write-buffered/disp32 1301 # . . discard args 1302 81 0/subop/add %esp 8/imm32 -1303 # check-ints-equal(_test-input-stream->read, 4, msg) +1303 # . flush(Stderr) 1304 # . . push args -1305 68/push "F - test-next-word-string-or-expression-without-metadata/updates-stream-read-correctly"/imm32 -1306 68/push 4/imm32 -1307 b8/copy-to-eax _test-input-stream/imm32 -1308 ff 6/subop/push *(eax+4) -1309 # . . call -1310 e8/call check-ints-equal/disp32 -1311 # . . discard args -1312 81 0/subop/add %esp 0xc/imm32 -1313 # check-ints-equal(slice->start - _test-input-stream->data, 2, msg) -1314 # . check-ints-equal(slice->start - _test-input-stream, 14, msg) -1315 # . . push args -1316 68/push "F - test-next-word-string-or-expression-without-metadata: start"/imm32 -1317 68/push 0xe/imm32 -1318 # . . push slice->start - _test-input-stream -1319 8b/-> *ecx 0/r32/eax -1320 81 5/subop/subtract %eax _test-input-stream/imm32 -1321 50/push-eax -1322 # . . call -1323 e8/call check-ints-equal/disp32 -1324 # . . discard args -1325 81 0/subop/add %esp 0xc/imm32 -1326 # check-ints-equal(slice->end - _test-input-stream->data, 4, msg) -1327 # . check-ints-equal(slice->end - _test-input-stream, 16, msg) -1328 # . . push args -1329 68/push "F - test-next-word-string-or-expression-without-metadata: end"/imm32 -1330 68/push 0x10/imm32 -1331 # . . push slice->end - _test-input-stream -1332 8b/-> *(ecx+4) 0/r32/eax -1333 81 5/subop/subtract %eax _test-input-stream/imm32 -1334 50/push-eax +1305 68/push Stderr/imm32 +1306 # . . call +1307 e8/call flush/disp32 +1308 # . . discard args +1309 81 0/subop/add %esp 4/imm32 +1310 # . syscall(exit, 1) +1311 bb/copy-to-ebx 1/imm32 +1312 e8/call syscall_exit/disp32 +1313 # never gets here +1314 +1315 test-next-word-string-or-expression-without-metadata: +1316 # . prologue +1317 55/push-ebp +1318 89/<- %ebp 4/r32/esp +1319 # setup +1320 # . clear-stream(_test-input-stream) +1321 # . . push args +1322 68/push _test-input-stream/imm32 +1323 # . . call +1324 e8/call clear-stream/disp32 +1325 # . . discard args +1326 81 0/subop/add %esp 4/imm32 +1327 # var slice/ecx: slice +1328 68/push 0/imm32/end +1329 68/push 0/imm32/start +1330 89/<- %ecx 4/r32/esp +1331 # write(_test-input-stream, " ab") +1332 # . . push args +1333 68/push " ab"/imm32 +1334 68/push _test-input-stream/imm32 1335 # . . call -1336 e8/call check-ints-equal/disp32 +1336 e8/call write/disp32 1337 # . . discard args -1338 81 0/subop/add %esp 0xc/imm32 -1339 # . epilogue -1340 89/<- %esp 5/r32/ebp -1341 5d/pop-to-ebp -1342 c3/return -1343 -1344 test-next-word-string-or-expression-without-metadata-returns-whole-comment: -1345 # . prologue -1346 55/push-ebp -1347 89/<- %ebp 4/r32/esp -1348 # setup -1349 # . clear-stream(_test-input-stream) -1350 # . . push args -1351 68/push _test-input-stream/imm32 -1352 # . . call -1353 e8/call clear-stream/disp32 -1354 # . . discard args -1355 81 0/subop/add %esp 4/imm32 -1356 # var slice/ecx: slice -1357 68/push 0/imm32/end -1358 68/push 0/imm32/start -1359 89/<- %ecx 4/r32/esp -1360 # write(_test-input-stream, " # a") -1361 # . . push args -1362 68/push " # a"/imm32 -1363 68/push _test-input-stream/imm32 -1364 # . . call -1365 e8/call write/disp32 -1366 # . . discard args -1367 81 0/subop/add %esp 8/imm32 -1368 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) -1369 # . . push args -1370 51/push-ecx -1371 68/push _test-input-stream/imm32 -1372 # . . call -1373 e8/call next-word-string-or-expression-without-metadata/disp32 -1374 # . . discard args -1375 81 0/subop/add %esp 8/imm32 -1376 # check-ints-equal(_test-input-stream->read, 5, msg) -1377 # . . push args -1378 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-comment/updates-stream-read-correctly"/imm32 -1379 68/push 5/imm32 -1380 b8/copy-to-eax _test-input-stream/imm32 -1381 ff 6/subop/push *(eax+4) -1382 # . . call -1383 e8/call check-ints-equal/disp32 -1384 # . . discard args -1385 81 0/subop/add %esp 0xc/imm32 -1386 # check-ints-equal(slice->start - _test-input-stream->data, 2, msg) -1387 # . check-ints-equal(slice->start - _test-input-stream, 14, msg) -1388 # . . push args -1389 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-comment: start"/imm32 -1390 68/push 0xe/imm32 -1391 # . . push slice->start - _test-input-stream -1392 8b/-> *ecx 0/r32/eax -1393 81 5/subop/subtract %eax _test-input-stream/imm32 -1394 50/push-eax -1395 # . . call -1396 e8/call check-ints-equal/disp32 -1397 # . . discard args -1398 81 0/subop/add %esp 0xc/imm32 -1399 # check-ints-equal(slice->end - _test-input-stream->data, 5, msg) -1400 # . check-ints-equal(slice->end - _test-input-stream, 17, msg) -1401 # . . push args -1402 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-comment: end"/imm32 -1403 68/push 0x11/imm32 -1404 # . . push slice->end - _test-input-stream -1405 8b/-> *(ecx+4) 0/r32/eax -1406 81 5/subop/subtract %eax _test-input-stream/imm32 -1407 50/push-eax +1338 81 0/subop/add %esp 8/imm32 +1339 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) +1340 # . . push args +1341 51/push-ecx +1342 68/push _test-input-stream/imm32 +1343 # . . call +1344 e8/call next-word-string-or-expression-without-metadata/disp32 +1345 # . . discard args +1346 81 0/subop/add %esp 8/imm32 +1347 # check-ints-equal(_test-input-stream->read, 4, msg) +1348 # . . push args +1349 68/push "F - test-next-word-string-or-expression-without-metadata/updates-stream-read-correctly"/imm32 +1350 68/push 4/imm32 +1351 b8/copy-to-eax _test-input-stream/imm32 +1352 ff 6/subop/push *(eax+4) +1353 # . . call +1354 e8/call check-ints-equal/disp32 +1355 # . . discard args +1356 81 0/subop/add %esp 0xc/imm32 +1357 # check-ints-equal(slice->start - _test-input-stream->data, 2, msg) +1358 # . check-ints-equal(slice->start - _test-input-stream, 14, msg) +1359 # . . push args +1360 68/push "F - test-next-word-string-or-expression-without-metadata: start"/imm32 +1361 68/push 0xe/imm32 +1362 # . . push slice->start - _test-input-stream +1363 8b/-> *ecx 0/r32/eax +1364 81 5/subop/subtract %eax _test-input-stream/imm32 +1365 50/push-eax +1366 # . . call +1367 e8/call check-ints-equal/disp32 +1368 # . . discard args +1369 81 0/subop/add %esp 0xc/imm32 +1370 # check-ints-equal(slice->end - _test-input-stream->data, 4, msg) +1371 # . check-ints-equal(slice->end - _test-input-stream, 16, msg) +1372 # . . push args +1373 68/push "F - test-next-word-string-or-expression-without-metadata: end"/imm32 +1374 68/push 0x10/imm32 +1375 # . . push slice->end - _test-input-stream +1376 8b/-> *(ecx+4) 0/r32/eax +1377 81 5/subop/subtract %eax _test-input-stream/imm32 +1378 50/push-eax +1379 # . . call +1380 e8/call check-ints-equal/disp32 +1381 # . . discard args +1382 81 0/subop/add %esp 0xc/imm32 +1383 # . epilogue +1384 89/<- %esp 5/r32/ebp +1385 5d/pop-to-ebp +1386 c3/return +1387 +1388 test-next-word-string-or-expression-without-metadata-returns-whole-comment: +1389 # . prologue +1390 55/push-ebp +1391 89/<- %ebp 4/r32/esp +1392 # setup +1393 # . clear-stream(_test-input-stream) +1394 # . . push args +1395 68/push _test-input-stream/imm32 +1396 # . . call +1397 e8/call clear-stream/disp32 +1398 # . . discard args +1399 81 0/subop/add %esp 4/imm32 +1400 # var slice/ecx: slice +1401 68/push 0/imm32/end +1402 68/push 0/imm32/start +1403 89/<- %ecx 4/r32/esp +1404 # write(_test-input-stream, " # a") +1405 # . . push args +1406 68/push " # a"/imm32 +1407 68/push _test-input-stream/imm32 1408 # . . call -1409 e8/call check-ints-equal/disp32 +1409 e8/call write/disp32 1410 # . . discard args -1411 81 0/subop/add %esp 0xc/imm32 -1412 # . epilogue -1413 89/<- %esp 5/r32/ebp -1414 5d/pop-to-ebp -1415 c3/return -1416 -1417 test-next-word-string-or-expression-without-metadata-returns-string-literal: -1418 # . prologue -1419 55/push-ebp -1420 89/<- %ebp 4/r32/esp -1421 # setup -1422 # . clear-stream(_test-input-stream) -1423 # . . push args -1424 68/push _test-input-stream/imm32 -1425 # . . call -1426 e8/call clear-stream/disp32 -1427 # . . discard args -1428 81 0/subop/add %esp 4/imm32 -1429 # var slice/ecx: slice -1430 68/push 0/imm32/end -1431 68/push 0/imm32/start -1432 89/<- %ecx 4/r32/esp -1433 # write(_test-input-stream, " \"a b\" ") -1434 # . . push args -1435 68/push " \"a b\" "/imm32 -1436 68/push _test-input-stream/imm32 -1437 # . . call -1438 e8/call write/disp32 -1439 # . . discard args -1440 81 0/subop/add %esp 8/imm32 -1441 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) -1442 # . . push args -1443 51/push-ecx -1444 68/push _test-input-stream/imm32 -1445 # . . call -1446 e8/call next-word-string-or-expression-without-metadata/disp32 -1447 # . . discard args -1448 81 0/subop/add %esp 8/imm32 -1449 # check-ints-equal(slice->start - _test-input-stream->data, 1, msg) -1450 # . check-ints-equal(slice->start - _test-input-stream, 13, msg) -1451 # . . push args -1452 68/push "F - test-next-word-string-or-expression-without-metadata-returns-string-literal: start"/imm32 -1453 68/push 0xd/imm32 -1454 # . . push slice->start - _test-input-stream -1455 8b/-> *ecx 0/r32/eax -1456 81 5/subop/subtract %eax _test-input-stream/imm32 -1457 50/push-eax -1458 # . . call -1459 e8/call check-ints-equal/disp32 -1460 # . . discard args -1461 81 0/subop/add %esp 0xc/imm32 -1462 # check-ints-equal(slice->end - _test-input-stream->data, 6, msg) -1463 # . check-ints-equal(slice->end - _test-input-stream, 18, msg) -1464 # . . push args -1465 68/push "F - test-next-word-string-or-expression-without-metadata-returns-string-literal: end"/imm32 -1466 68/push 0x12/imm32 -1467 # . . push slice->end - _test-input-stream -1468 8b/-> *(ecx+4) 0/r32/eax -1469 81 5/subop/subtract %eax _test-input-stream/imm32 -1470 50/push-eax -1471 # . . call -1472 e8/call check-ints-equal/disp32 -1473 # . . discard args -1474 81 0/subop/add %esp 0xc/imm32 -1475 # . epilogue -1476 89/<- %esp 5/r32/ebp -1477 5d/pop-to-ebp -1478 c3/return -1479 -1480 test-next-word-string-or-expression-without-metadata-returns-string-with-escapes: -1481 # . prologue -1482 55/push-ebp -1483 89/<- %ebp 4/r32/esp -1484 # setup -1485 # . clear-stream(_test-input-stream) +1411 81 0/subop/add %esp 8/imm32 +1412 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) +1413 # . . push args +1414 51/push-ecx +1415 68/push _test-input-stream/imm32 +1416 # . . call +1417 e8/call next-word-string-or-expression-without-metadata/disp32 +1418 # . . discard args +1419 81 0/subop/add %esp 8/imm32 +1420 # check-ints-equal(_test-input-stream->read, 5, msg) +1421 # . . push args +1422 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-comment/updates-stream-read-correctly"/imm32 +1423 68/push 5/imm32 +1424 b8/copy-to-eax _test-input-stream/imm32 +1425 ff 6/subop/push *(eax+4) +1426 # . . call +1427 e8/call check-ints-equal/disp32 +1428 # . . discard args +1429 81 0/subop/add %esp 0xc/imm32 +1430 # check-ints-equal(slice->start - _test-input-stream->data, 2, msg) +1431 # . check-ints-equal(slice->start - _test-input-stream, 14, msg) +1432 # . . push args +1433 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-comment: start"/imm32 +1434 68/push 0xe/imm32 +1435 # . . push slice->start - _test-input-stream +1436 8b/-> *ecx 0/r32/eax +1437 81 5/subop/subtract %eax _test-input-stream/imm32 +1438 50/push-eax +1439 # . . call +1440 e8/call check-ints-equal/disp32 +1441 # . . discard args +1442 81 0/subop/add %esp 0xc/imm32 +1443 # check-ints-equal(slice->end - _test-input-stream->data, 5, msg) +1444 # . check-ints-equal(slice->end - _test-input-stream, 17, msg) +1445 # . . push args +1446 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-comment: end"/imm32 +1447 68/push 0x11/imm32 +1448 # . . push slice->end - _test-input-stream +1449 8b/-> *(ecx+4) 0/r32/eax +1450 81 5/subop/subtract %eax _test-input-stream/imm32 +1451 50/push-eax +1452 # . . call +1453 e8/call check-ints-equal/disp32 +1454 # . . discard args +1455 81 0/subop/add %esp 0xc/imm32 +1456 # . epilogue +1457 89/<- %esp 5/r32/ebp +1458 5d/pop-to-ebp +1459 c3/return +1460 +1461 test-next-word-string-or-expression-without-metadata-returns-string-literal: +1462 # . prologue +1463 55/push-ebp +1464 89/<- %ebp 4/r32/esp +1465 # setup +1466 # . clear-stream(_test-input-stream) +1467 # . . push args +1468 68/push _test-input-stream/imm32 +1469 # . . call +1470 e8/call clear-stream/disp32 +1471 # . . discard args +1472 81 0/subop/add %esp 4/imm32 +1473 # var slice/ecx: slice +1474 68/push 0/imm32/end +1475 68/push 0/imm32/start +1476 89/<- %ecx 4/r32/esp +1477 # write(_test-input-stream, " \"a b\" ") +1478 # . . push args +1479 68/push " \"a b\" "/imm32 +1480 68/push _test-input-stream/imm32 +1481 # . . call +1482 e8/call write/disp32 +1483 # . . discard args +1484 81 0/subop/add %esp 8/imm32 +1485 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) 1486 # . . push args -1487 68/push _test-input-stream/imm32 -1488 # . . call -1489 e8/call clear-stream/disp32 -1490 # . . discard args -1491 81 0/subop/add %esp 4/imm32 -1492 # var slice/ecx: slice -1493 68/push 0/imm32/end -1494 68/push 0/imm32/start -1495 89/<- %ecx 4/r32/esp -1496 # write(_test-input-stream, " \"a\\\"b\"") -1497 # . . push args -1498 68/push " \"a\\\"b\""/imm32 -1499 68/push _test-input-stream/imm32 -1500 # . . call -1501 e8/call write/disp32 -1502 # . . discard args -1503 81 0/subop/add %esp 8/imm32 -1504 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) -1505 # . . push args -1506 51/push-ecx -1507 68/push _test-input-stream/imm32 -1508 # . . call -1509 e8/call next-word-string-or-expression-without-metadata/disp32 -1510 # . . discard args -1511 81 0/subop/add %esp 8/imm32 -1512 # check-ints-equal(slice->start - _test-input-stream->data, 1, msg) -1513 # . check-ints-equal(slice->start - _test-input-stream, 13, msg) -1514 # . . push args -1515 68/push "F - test-next-word-string-or-expression-without-metadata-returns-string-with-escapes: start"/imm32 -1516 68/push 0xd/imm32 -1517 # . . push slice->start - _test-input-stream -1518 8b/-> *ecx 0/r32/eax -1519 81 5/subop/subtract %eax _test-input-stream/imm32 -1520 50/push-eax -1521 # . . call -1522 e8/call check-ints-equal/disp32 -1523 # . . discard args -1524 81 0/subop/add %esp 0xc/imm32 -1525 # check-ints-equal(slice->end - _test-input-stream->data, 7, msg) -1526 # . check-ints-equal(slice->end - _test-input-stream, 19, msg) -1527 # . . push args -1528 68/push "F - test-next-word-string-or-expression-without-metadata-returns-string-with-escapes: end"/imm32 -1529 68/push 0x13/imm32 -1530 # . . push slice->end - _test-input-stream -1531 8b/-> *(ecx+4) 0/r32/eax -1532 81 5/subop/subtract %eax _test-input-stream/imm32 -1533 50/push-eax -1534 # . . call -1535 e8/call check-ints-equal/disp32 -1536 # . . discard args -1537 81 0/subop/add %esp 0xc/imm32 -1538 # . epilogue -1539 89/<- %esp 5/r32/ebp -1540 5d/pop-to-ebp -1541 c3/return -1542 -1543 test-next-word-string-or-expression-without-metadata-returns-whole-expression: -1544 # . prologue -1545 55/push-ebp -1546 89/<- %ebp 4/r32/esp -1547 # setup -1548 # . clear-stream(_test-input-stream) +1487 51/push-ecx +1488 68/push _test-input-stream/imm32 +1489 # . . call +1490 e8/call next-word-string-or-expression-without-metadata/disp32 +1491 # . . discard args +1492 81 0/subop/add %esp 8/imm32 +1493 # check-ints-equal(slice->start - _test-input-stream->data, 1, msg) +1494 # . check-ints-equal(slice->start - _test-input-stream, 13, msg) +1495 # . . push args +1496 68/push "F - test-next-word-string-or-expression-without-metadata-returns-string-literal: start"/imm32 +1497 68/push 0xd/imm32 +1498 # . . push slice->start - _test-input-stream +1499 8b/-> *ecx 0/r32/eax +1500 81 5/subop/subtract %eax _test-input-stream/imm32 +1501 50/push-eax +1502 # . . call +1503 e8/call check-ints-equal/disp32 +1504 # . . discard args +1505 81 0/subop/add %esp 0xc/imm32 +1506 # check-ints-equal(slice->end - _test-input-stream->data, 6, msg) +1507 # . check-ints-equal(slice->end - _test-input-stream, 18, msg) +1508 # . . push args +1509 68/push "F - test-next-word-string-or-expression-without-metadata-returns-string-literal: end"/imm32 +1510 68/push 0x12/imm32 +1511 # . . push slice->end - _test-input-stream +1512 8b/-> *(ecx+4) 0/r32/eax +1513 81 5/subop/subtract %eax _test-input-stream/imm32 +1514 50/push-eax +1515 # . . call +1516 e8/call check-ints-equal/disp32 +1517 # . . discard args +1518 81 0/subop/add %esp 0xc/imm32 +1519 # . epilogue +1520 89/<- %esp 5/r32/ebp +1521 5d/pop-to-ebp +1522 c3/return +1523 +1524 test-next-word-string-or-expression-without-metadata-returns-string-with-escapes: +1525 # . prologue +1526 55/push-ebp +1527 89/<- %ebp 4/r32/esp +1528 # setup +1529 # . clear-stream(_test-input-stream) +1530 # . . push args +1531 68/push _test-input-stream/imm32 +1532 # . . call +1533 e8/call clear-stream/disp32 +1534 # . . discard args +1535 81 0/subop/add %esp 4/imm32 +1536 # var slice/ecx: slice +1537 68/push 0/imm32/end +1538 68/push 0/imm32/start +1539 89/<- %ecx 4/r32/esp +1540 # write(_test-input-stream, " \"a\\\"b\"") +1541 # . . push args +1542 68/push " \"a\\\"b\""/imm32 +1543 68/push _test-input-stream/imm32 +1544 # . . call +1545 e8/call write/disp32 +1546 # . . discard args +1547 81 0/subop/add %esp 8/imm32 +1548 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) 1549 # . . push args -1550 68/push _test-input-stream/imm32 -1551 # . . call -1552 e8/call clear-stream/disp32 -1553 # . . discard args -1554 81 0/subop/add %esp 4/imm32 -1555 # var slice/ecx: slice -1556 68/push 0/imm32/end -1557 68/push 0/imm32/start -1558 89/<- %ecx 4/r32/esp -1559 # write(_test-input-stream, " *(a b) ") -1560 # . . push args -1561 68/push " *(a b) "/imm32 -1562 68/push _test-input-stream/imm32 -1563 # . . call -1564 e8/call write/disp32 -1565 # . . discard args -1566 81 0/subop/add %esp 8/imm32 -1567 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) -1568 # . . push args -1569 51/push-ecx -1570 68/push _test-input-stream/imm32 -1571 # . . call -1572 e8/call next-word-string-or-expression-without-metadata/disp32 -1573 # . . discard args -1574 81 0/subop/add %esp 8/imm32 -1575 # check-ints-equal(slice->start - _test-input-stream->data, 1, msg) -1576 # . check-ints-equal(slice->start - _test-input-stream, 13, msg) -1577 # . . push args -1578 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-expression: start"/imm32 -1579 68/push 0xd/imm32 -1580 # . . push slice->start - _test-input-stream -1581 8b/-> *ecx 0/r32/eax -1582 81 5/subop/subtract %eax _test-input-stream/imm32 -1583 50/push-eax -1584 # . . call -1585 e8/call check-ints-equal/disp32 -1586 # . . discard args -1587 81 0/subop/add %esp 0xc/imm32 -1588 # check-ints-equal(slice->end - _test-input-stream->data, 7, msg) -1589 # . check-ints-equal(slice->end - _test-input-stream, 19, msg) -1590 # . . push args -1591 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-expression: end"/imm32 -1592 68/push 0x13/imm32 -1593 # . . push slice->end - _test-input-stream -1594 8b/-> *(ecx+4) 0/r32/eax -1595 81 5/subop/subtract %eax _test-input-stream/imm32 -1596 50/push-eax -1597 # . . call -1598 e8/call check-ints-equal/disp32 -1599 # . . discard args -1600 81 0/subop/add %esp 0xc/imm32 -1601 # . epilogue -1602 89/<- %esp 5/r32/ebp -1603 5d/pop-to-ebp -1604 c3/return -1605 -1606 test-next-word-string-or-expression-without-metadata-returns-eol-on-trailing-close-paren: -1607 # . prologue -1608 55/push-ebp -1609 89/<- %ebp 4/r32/esp -1610 # setup -1611 # . clear-stream(_test-input-stream) +1550 51/push-ecx +1551 68/push _test-input-stream/imm32 +1552 # . . call +1553 e8/call next-word-string-or-expression-without-metadata/disp32 +1554 # . . discard args +1555 81 0/subop/add %esp 8/imm32 +1556 # check-ints-equal(slice->start - _test-input-stream->data, 1, msg) +1557 # . check-ints-equal(slice->start - _test-input-stream, 13, msg) +1558 # . . push args +1559 68/push "F - test-next-word-string-or-expression-without-metadata-returns-string-with-escapes: start"/imm32 +1560 68/push 0xd/imm32 +1561 # . . push slice->start - _test-input-stream +1562 8b/-> *ecx 0/r32/eax +1563 81 5/subop/subtract %eax _test-input-stream/imm32 +1564 50/push-eax +1565 # . . call +1566 e8/call check-ints-equal/disp32 +1567 # . . discard args +1568 81 0/subop/add %esp 0xc/imm32 +1569 # check-ints-equal(slice->end - _test-input-stream->data, 7, msg) +1570 # . check-ints-equal(slice->end - _test-input-stream, 19, msg) +1571 # . . push args +1572 68/push "F - test-next-word-string-or-expression-without-metadata-returns-string-with-escapes: end"/imm32 +1573 68/push 0x13/imm32 +1574 # . . push slice->end - _test-input-stream +1575 8b/-> *(ecx+4) 0/r32/eax +1576 81 5/subop/subtract %eax _test-input-stream/imm32 +1577 50/push-eax +1578 # . . call +1579 e8/call check-ints-equal/disp32 +1580 # . . discard args +1581 81 0/subop/add %esp 0xc/imm32 +1582 # . epilogue +1583 89/<- %esp 5/r32/ebp +1584 5d/pop-to-ebp +1585 c3/return +1586 +1587 test-next-word-string-or-expression-without-metadata-returns-whole-expression: +1588 # . prologue +1589 55/push-ebp +1590 89/<- %ebp 4/r32/esp +1591 # setup +1592 # . clear-stream(_test-input-stream) +1593 # . . push args +1594 68/push _test-input-stream/imm32 +1595 # . . call +1596 e8/call clear-stream/disp32 +1597 # . . discard args +1598 81 0/subop/add %esp 4/imm32 +1599 # var slice/ecx: slice +1600 68/push 0/imm32/end +1601 68/push 0/imm32/start +1602 89/<- %ecx 4/r32/esp +1603 # write(_test-input-stream, " *(a b) ") +1604 # . . push args +1605 68/push " *(a b) "/imm32 +1606 68/push _test-input-stream/imm32 +1607 # . . call +1608 e8/call write/disp32 +1609 # . . discard args +1610 81 0/subop/add %esp 8/imm32 +1611 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) 1612 # . . push args -1613 68/push _test-input-stream/imm32 -1614 # . . call -1615 e8/call clear-stream/disp32 -1616 # . . discard args -1617 81 0/subop/add %esp 4/imm32 -1618 # var slice/ecx: slice -1619 68/push 0/imm32/end -1620 68/push 0/imm32/start -1621 89/<- %ecx 4/r32/esp -1622 # write(_test-input-stream, " ) ") -1623 # . . push args -1624 68/push " ) "/imm32 -1625 68/push _test-input-stream/imm32 -1626 # . . call -1627 e8/call write/disp32 -1628 # . . discard args -1629 81 0/subop/add %esp 8/imm32 -1630 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) -1631 # . . push args -1632 51/push-ecx -1633 68/push _test-input-stream/imm32 -1634 # . . call -1635 e8/call next-word-string-or-expression-without-metadata/disp32 -1636 # . . discard args -1637 81 0/subop/add %esp 8/imm32 -1638 # check-ints-equal(slice->start, 0, msg) -1639 # . . push args -1640 68/push "F - test-next-word-string-or-expression-without-metadata-returns-eol-on-trailing-close-paren: start"/imm32 -1641 68/push 0/imm32 -1642 ff 6/subop/push *ecx -1643 # . . call -1644 e8/call check-ints-equal/disp32 -1645 # . . discard args -1646 81 0/subop/add %esp 0xc/imm32 -1647 # check-ints-equal(slice->end, 0, msg) -1648 # . . push args -1649 68/push "F - test-next-word-string-or-expression-without-metadata-returns-eol-on-trailing-close-paren: end"/imm32 -1650 68/push 0/imm32 -1651 ff 6/subop/push *(ecx+4) -1652 # . . call -1653 e8/call check-ints-equal/disp32 -1654 # . . discard args -1655 81 0/subop/add %esp 0xc/imm32 -1656 # . epilogue -1657 89/<- %esp 5/r32/ebp -1658 5d/pop-to-ebp -1659 c3/return -1660 -1661 test-next-word-string-or-expression-without-metadata-handles-comment-after-trailing-close-paren: -1662 # . prologue -1663 55/push-ebp -1664 89/<- %ebp 4/r32/esp -1665 # setup -1666 # . clear-stream(_test-input-stream) +1613 51/push-ecx +1614 68/push _test-input-stream/imm32 +1615 # . . call +1616 e8/call next-word-string-or-expression-without-metadata/disp32 +1617 # . . discard args +1618 81 0/subop/add %esp 8/imm32 +1619 # check-ints-equal(slice->start - _test-input-stream->data, 1, msg) +1620 # . check-ints-equal(slice->start - _test-input-stream, 13, msg) +1621 # . . push args +1622 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-expression: start"/imm32 +1623 68/push 0xd/imm32 +1624 # . . push slice->start - _test-input-stream +1625 8b/-> *ecx 0/r32/eax +1626 81 5/subop/subtract %eax _test-input-stream/imm32 +1627 50/push-eax +1628 # . . call +1629 e8/call check-ints-equal/disp32 +1630 # . . discard args +1631 81 0/subop/add %esp 0xc/imm32 +1632 # check-ints-equal(slice->end - _test-input-stream->data, 7, msg) +1633 # . check-ints-equal(slice->end - _test-input-stream, 19, msg) +1634 # . . push args +1635 68/push "F - test-next-word-string-or-expression-without-metadata-returns-whole-expression: end"/imm32 +1636 68/push 0x13/imm32 +1637 # . . push slice->end - _test-input-stream +1638 8b/-> *(ecx+4) 0/r32/eax +1639 81 5/subop/subtract %eax _test-input-stream/imm32 +1640 50/push-eax +1641 # . . call +1642 e8/call check-ints-equal/disp32 +1643 # . . discard args +1644 81 0/subop/add %esp 0xc/imm32 +1645 # . epilogue +1646 89/<- %esp 5/r32/ebp +1647 5d/pop-to-ebp +1648 c3/return +1649 +1650 test-next-word-string-or-expression-without-metadata-returns-eol-on-trailing-close-paren: +1651 # . prologue +1652 55/push-ebp +1653 89/<- %ebp 4/r32/esp +1654 # setup +1655 # . clear-stream(_test-input-stream) +1656 # . . push args +1657 68/push _test-input-stream/imm32 +1658 # . . call +1659 e8/call clear-stream/disp32 +1660 # . . discard args +1661 81 0/subop/add %esp 4/imm32 +1662 # var slice/ecx: slice +1663 68/push 0/imm32/end +1664 68/push 0/imm32/start +1665 89/<- %ecx 4/r32/esp +1666 # write(_test-input-stream, " ) ") 1667 # . . push args -1668 68/push _test-input-stream/imm32 -1669 # . . call -1670 e8/call clear-stream/disp32 -1671 # . . discard args -1672 81 0/subop/add %esp 4/imm32 -1673 # var slice/ecx: slice -1674 68/push 0/imm32/end -1675 68/push 0/imm32/start -1676 89/<- %ecx 4/r32/esp -1677 # write(_test-input-stream, " ) # abc ") -1678 # . . push args -1679 68/push " ) # abc "/imm32 -1680 68/push _test-input-stream/imm32 -1681 # . . call -1682 e8/call write/disp32 -1683 # . . discard args -1684 81 0/subop/add %esp 8/imm32 -1685 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) -1686 # . . push args -1687 51/push-ecx -1688 68/push _test-input-stream/imm32 -1689 # . . call -1690 e8/call next-word-string-or-expression-without-metadata/disp32 -1691 # . . discard args -1692 81 0/subop/add %esp 8/imm32 -1693 # check-ints-equal(slice->start, 0, msg) -1694 # . . push args -1695 68/push "F - test-next-word-string-or-expression-without-metadata-handles-comment-after-trailing-close-paren: start"/imm32 -1696 68/push 0/imm32 -1697 ff 6/subop/push *ecx -1698 # . . call -1699 e8/call check-ints-equal/disp32 -1700 # . . discard args -1701 81 0/subop/add %esp 0xc/imm32 -1702 # check-ints-equal(slice->end, 0, msg) -1703 # . . push args -1704 68/push "F - test-next-word-string-or-expression-without-metadata-handles-comment-after-trailing-close-paren: end"/imm32 -1705 68/push 0/imm32 -1706 ff 6/subop/push *(ecx+4) -1707 # . . call -1708 e8/call check-ints-equal/disp32 -1709 # . . discard args -1710 81 0/subop/add %esp 0xc/imm32 -1711 # . epilogue -1712 89/<- %esp 5/r32/ebp -1713 5d/pop-to-ebp -1714 c3/return -1715 -1716 test-next-word-string-or-expression-without-metadata-handles-newline-after-trailing-close-paren: -1717 # . prologue -1718 55/push-ebp -1719 89/<- %ebp 4/r32/esp -1720 # setup -1721 # . clear-stream(_test-input-stream) +1668 68/push " ) "/imm32 +1669 68/push _test-input-stream/imm32 +1670 # . . call +1671 e8/call write/disp32 +1672 # . . discard args +1673 81 0/subop/add %esp 8/imm32 +1674 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) +1675 # . . push args +1676 51/push-ecx +1677 68/push _test-input-stream/imm32 +1678 # . . call +1679 e8/call next-word-string-or-expression-without-metadata/disp32 +1680 # . . discard args +1681 81 0/subop/add %esp 8/imm32 +1682 # check-ints-equal(slice->start, 0, msg) +1683 # . . push args +1684 68/push "F - test-next-word-string-or-expression-without-metadata-returns-eol-on-trailing-close-paren: start"/imm32 +1685 68/push 0/imm32 +1686 ff 6/subop/push *ecx +1687 # . . call +1688 e8/call check-ints-equal/disp32 +1689 # . . discard args +1690 81 0/subop/add %esp 0xc/imm32 +1691 # check-ints-equal(slice->end, 0, msg) +1692 # . . push args +1693 68/push "F - test-next-word-string-or-expression-without-metadata-returns-eol-on-trailing-close-paren: end"/imm32 +1694 68/push 0/imm32 +1695 ff 6/subop/push *(ecx+4) +1696 # . . call +1697 e8/call check-ints-equal/disp32 +1698 # . . discard args +1699 81 0/subop/add %esp 0xc/imm32 +1700 # . epilogue +1701 89/<- %esp 5/r32/ebp +1702 5d/pop-to-ebp +1703 c3/return +1704 +1705 test-next-word-string-or-expression-without-metadata-handles-comment-after-trailing-close-paren: +1706 # . prologue +1707 55/push-ebp +1708 89/<- %ebp 4/r32/esp +1709 # setup +1710 # . clear-stream(_test-input-stream) +1711 # . . push args +1712 68/push _test-input-stream/imm32 +1713 # . . call +1714 e8/call clear-stream/disp32 +1715 # . . discard args +1716 81 0/subop/add %esp 4/imm32 +1717 # var slice/ecx: slice +1718 68/push 0/imm32/end +1719 68/push 0/imm32/start +1720 89/<- %ecx 4/r32/esp +1721 # write(_test-input-stream, " ) # abc ") 1722 # . . push args -1723 68/push _test-input-stream/imm32 -1724 # . . call -1725 e8/call clear-stream/disp32 -1726 # . . discard args -1727 81 0/subop/add %esp 4/imm32 -1728 # var slice/ecx: slice -1729 68/push 0/imm32/end -1730 68/push 0/imm32/start -1731 89/<- %ecx 4/r32/esp -1732 # write(_test-input-stream, " )\n") -1733 # . . push args -1734 68/push " )\n"/imm32 -1735 68/push _test-input-stream/imm32 -1736 # . . call -1737 e8/call write/disp32 -1738 # . . discard args -1739 81 0/subop/add %esp 8/imm32 -1740 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) -1741 # . . push args -1742 51/push-ecx -1743 68/push _test-input-stream/imm32 -1744 # . . call -1745 e8/call next-word-string-or-expression-without-metadata/disp32 -1746 # . . discard args -1747 81 0/subop/add %esp 8/imm32 -1748 # check-ints-equal(slice->start, 0, msg) -1749 # . . push args -1750 68/push "F - test-next-word-string-or-expression-without-metadata-handles-newline-after-trailing-close-paren: start"/imm32 -1751 68/push 0/imm32 -1752 ff 6/subop/push *ecx -1753 # . . call -1754 e8/call check-ints-equal/disp32 -1755 # . . discard args -1756 81 0/subop/add %esp 0xc/imm32 -1757 # check-ints-equal(slice->end, 0, msg) -1758 # . . push args -1759 68/push "F - test-next-word-string-or-expression-without-metadata-handles-newline-after-trailing-close-paren: end"/imm32 -1760 68/push 0/imm32 -1761 ff 6/subop/push *(ecx+4) -1762 # . . call -1763 e8/call check-ints-equal/disp32 -1764 # . . discard args -1765 81 0/subop/add %esp 0xc/imm32 -1766 # . epilogue -1767 89/<- %esp 5/r32/ebp -1768 5d/pop-to-ebp -1769 c3/return -1770 -1771 test-next-word-string-or-expression-without-metadata-stops-at-close-paren: -1772 # . prologue -1773 55/push-ebp -1774 89/<- %ebp 4/r32/esp -1775 # setup -1776 # . clear-stream(_test-input-stream) +1723 68/push " ) # abc "/imm32 +1724 68/push _test-input-stream/imm32 +1725 # . . call +1726 e8/call write/disp32 +1727 # . . discard args +1728 81 0/subop/add %esp 8/imm32 +1729 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) +1730 # . . push args +1731 51/push-ecx +1732 68/push _test-input-stream/imm32 +1733 # . . call +1734 e8/call next-word-string-or-expression-without-metadata/disp32 +1735 # . . discard args +1736 81 0/subop/add %esp 8/imm32 +1737 # check-ints-equal(slice->start, 0, msg) +1738 # . . push args +1739 68/push "F - test-next-word-string-or-expression-without-metadata-handles-comment-after-trailing-close-paren: start"/imm32 +1740 68/push 0/imm32 +1741 ff 6/subop/push *ecx +1742 # . . call +1743 e8/call check-ints-equal/disp32 +1744 # . . discard args +1745 81 0/subop/add %esp 0xc/imm32 +1746 # check-ints-equal(slice->end, 0, msg) +1747 # . . push args +1748 68/push "F - test-next-word-string-or-expression-without-metadata-handles-comment-after-trailing-close-paren: end"/imm32 +1749 68/push 0/imm32 +1750 ff 6/subop/push *(ecx+4) +1751 # . . call +1752 e8/call check-ints-equal/disp32 +1753 # . . discard args +1754 81 0/subop/add %esp 0xc/imm32 +1755 # . epilogue +1756 89/<- %esp 5/r32/ebp +1757 5d/pop-to-ebp +1758 c3/return +1759 +1760 test-next-word-string-or-expression-without-metadata-handles-newline-after-trailing-close-paren: +1761 # . prologue +1762 55/push-ebp +1763 89/<- %ebp 4/r32/esp +1764 # setup +1765 # . clear-stream(_test-input-stream) +1766 # . . push args +1767 68/push _test-input-stream/imm32 +1768 # . . call +1769 e8/call clear-stream/disp32 +1770 # . . discard args +1771 81 0/subop/add %esp 4/imm32 +1772 # var slice/ecx: slice +1773 68/push 0/imm32/end +1774 68/push 0/imm32/start +1775 89/<- %ecx 4/r32/esp +1776 # write(_test-input-stream, " )\n") 1777 # . . push args -1778 68/push _test-input-stream/imm32 -1779 # . . call -1780 e8/call clear-stream/disp32 -1781 # . . discard args -1782 81 0/subop/add %esp 4/imm32 -1783 # var slice/ecx: slice -1784 68/push 0/imm32/end -1785 68/push 0/imm32/start -1786 89/<- %ecx 4/r32/esp -1787 # write(_test-input-stream, " abc) # def") -1788 # . . push args -1789 68/push " abc) # def"/imm32 -1790 68/push _test-input-stream/imm32 -1791 # . . call -1792 e8/call write/disp32 -1793 # . . discard args -1794 81 0/subop/add %esp 8/imm32 -1795 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) -1796 # . . push args -1797 51/push-ecx -1798 68/push _test-input-stream/imm32 -1799 # . . call -1800 e8/call next-word-string-or-expression-without-metadata/disp32 -1801 # . . discard args -1802 81 0/subop/add %esp 8/imm32 -1803 # check-ints-equal(slice->start - _test-input-stream->data, 1, msg) -1804 # . check-ints-equal(slice->start - _test-input-stream, 13, msg) -1805 # . . push args -1806 68/push "F - test-next-word-string-or-expression-without-metadata-stops-at-close-paren: start"/imm32 -1807 68/push 0xd/imm32 -1808 # . . push slice->start - _test-input-stream -1809 8b/-> *ecx 0/r32/eax -1810 81 5/subop/subtract %eax _test-input-stream/imm32 -1811 50/push-eax -1812 # . . call -1813 e8/call check-ints-equal/disp32 -1814 # . . discard args -1815 81 0/subop/add %esp 0xc/imm32 -1816 # check-ints-equal(slice->end - _test-input-stream->data, 4, msg) -1817 # . check-ints-equal(slice->end - _test-input-stream, 16, msg) -1818 # . . push args -1819 68/push "F - test-next-word-string-or-expression-without-metadata-stops-at-close-paren: end"/imm32 -1820 68/push 0x10/imm32 -1821 # . . push slice->end - _test-input-stream -1822 8b/-> *(ecx+4) 0/r32/eax -1823 81 5/subop/subtract %eax _test-input-stream/imm32 -1824 50/push-eax -1825 # . . call -1826 e8/call check-ints-equal/disp32 -1827 # . . discard args -1828 81 0/subop/add %esp 0xc/imm32 -1829 # . epilogue -1830 89/<- %esp 5/r32/ebp -1831 5d/pop-to-ebp -1832 c3/return +1778 68/push " )\n"/imm32 +1779 68/push _test-input-stream/imm32 +1780 # . . call +1781 e8/call write/disp32 +1782 # . . discard args +1783 81 0/subop/add %esp 8/imm32 +1784 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) +1785 # . . push args +1786 51/push-ecx +1787 68/push _test-input-stream/imm32 +1788 # . . call +1789 e8/call next-word-string-or-expression-without-metadata/disp32 +1790 # . . discard args +1791 81 0/subop/add %esp 8/imm32 +1792 # check-ints-equal(slice->start, 0, msg) +1793 # . . push args +1794 68/push "F - test-next-word-string-or-expression-without-metadata-handles-newline-after-trailing-close-paren: start"/imm32 +1795 68/push 0/imm32 +1796 ff 6/subop/push *ecx +1797 # . . call +1798 e8/call check-ints-equal/disp32 +1799 # . . discard args +1800 81 0/subop/add %esp 0xc/imm32 +1801 # check-ints-equal(slice->end, 0, msg) +1802 # . . push args +1803 68/push "F - test-next-word-string-or-expression-without-metadata-handles-newline-after-trailing-close-paren: end"/imm32 +1804 68/push 0/imm32 +1805 ff 6/subop/push *(ecx+4) +1806 # . . call +1807 e8/call check-ints-equal/disp32 +1808 # . . discard args +1809 81 0/subop/add %esp 0xc/imm32 +1810 # . epilogue +1811 89/<- %esp 5/r32/ebp +1812 5d/pop-to-ebp +1813 c3/return +1814 +1815 test-next-word-string-or-expression-without-metadata-stops-at-close-paren: +1816 # . prologue +1817 55/push-ebp +1818 89/<- %ebp 4/r32/esp +1819 # setup +1820 # . clear-stream(_test-input-stream) +1821 # . . push args +1822 68/push _test-input-stream/imm32 +1823 # . . call +1824 e8/call clear-stream/disp32 +1825 # . . discard args +1826 81 0/subop/add %esp 4/imm32 +1827 # var slice/ecx: slice +1828 68/push 0/imm32/end +1829 68/push 0/imm32/start +1830 89/<- %ecx 4/r32/esp +1831 # write(_test-input-stream, " abc) # def") +1832 # . . push args +1833 68/push " abc) # def"/imm32 +1834 68/push _test-input-stream/imm32 +1835 # . . call +1836 e8/call write/disp32 +1837 # . . discard args +1838 81 0/subop/add %esp 8/imm32 +1839 # next-word-string-or-expression-without-metadata(_test-input-stream, slice) +1840 # . . push args +1841 51/push-ecx +1842 68/push _test-input-stream/imm32 +1843 # . . call +1844 e8/call next-word-string-or-expression-without-metadata/disp32 +1845 # . . discard args +1846 81 0/subop/add %esp 8/imm32 +1847 # check-ints-equal(slice->start - _test-input-stream->data, 1, msg) +1848 # . check-ints-equal(slice->start - _test-input-stream, 13, msg) +1849 # . . push args +1850 68/push "F - test-next-word-string-or-expression-without-metadata-stops-at-close-paren: start"/imm32 +1851 68/push 0xd/imm32 +1852 # . . push slice->start - _test-input-stream +1853 8b/-> *ecx 0/r32/eax +1854 81 5/subop/subtract %eax _test-input-stream/imm32 +1855 50/push-eax +1856 # . . call +1857 e8/call check-ints-equal/disp32 +1858 # . . discard args +1859 81 0/subop/add %esp 0xc/imm32 +1860 # check-ints-equal(slice->end - _test-input-stream->data, 4, msg) +1861 # . check-ints-equal(slice->end - _test-input-stream, 16, msg) +1862 # . . push args +1863 68/push "F - test-next-word-string-or-expression-without-metadata-stops-at-close-paren: end"/imm32 +1864 68/push 0x10/imm32 +1865 # . . push slice->end - _test-input-stream +1866 8b/-> *(ecx+4) 0/r32/eax +1867 81 5/subop/subtract %eax _test-input-stream/imm32 +1868 50/push-eax +1869 # . . call +1870 e8/call check-ints-equal/disp32 +1871 # . . discard args +1872 81 0/subop/add %esp 0xc/imm32 +1873 # . epilogue +1874 89/<- %esp 5/r32/ebp +1875 5d/pop-to-ebp +1876 c3/return diff --git a/html/apps/hex.subx.html b/html/apps/hex.subx.html index 854f1581..a7373f0d 100644 --- a/html/apps/hex.subx.html +++ b/html/apps/hex.subx.html @@ -315,7 +315,7 @@ if ('onhashchange' in window) { 254 # eax = convert-next-octet(_test-buffered-file, _test-error-buffered-file, ed) 255 # . . push args 256 51/push-ecx/ed - 257 68/push _test-error-buffered-file/imm32 + 257 68/push _test-error-buffered-file/imm32 258 68/push _test-buffered-file/imm32 259 # . . call 260 e8/call convert-next-octet/disp32 @@ -405,7 +405,7 @@ if ('onhashchange' in window) { 344 # eax = convert-next-octet(_test-buffered-file, _test-error-buffered-file, ed) 345 # . . push args 346 51/push-ecx/ed - 347 68/push _test-error-buffered-file/imm32 + 347 68/push _test-error-buffered-file/imm32 348 68/push _test-buffered-file/imm32 349 # . . call 350 e8/call convert-next-octet/disp32 @@ -503,7 +503,7 @@ if ('onhashchange' in window) { 442 # eax = convert-next-octet(_test-buffered-file, _test-error-buffered-file, ed) 443 # . . push args 444 51/push-ecx/ed - 445 68/push _test-error-buffered-file/imm32 + 445 68/push _test-error-buffered-file/imm32 446 68/push _test-buffered-file/imm32 447 # . . call 448 e8/call convert-next-octet/disp32 @@ -672,7 +672,7 @@ if ('onhashchange' in window) { 611 # eax = scan-next-byte(_test-buffered-file, _test-error-buffered-file, ed) 612 # . . push args 613 51/push-ecx/ed - 614 68/push _test-error-buffered-file/imm32 + 614 68/push _test-error-buffered-file/imm32 615 68/push _test-buffered-file/imm32 616 # . . call 617 e8/call scan-next-byte/disp32 @@ -770,7 +770,7 @@ if ('onhashchange' in window) { 709 # eax = scan-next-byte(_test-buffered-file, _test-error-buffered-file, ed) 710 # . . push args 711 51/push-ecx/ed - 712 68/push _test-error-buffered-file/imm32 + 712 68/push _test-error-buffered-file/imm32 713 68/push _test-buffered-file/imm32 714 # . . call 715 e8/call scan-next-byte/disp32 @@ -876,7 +876,7 @@ if ('onhashchange' in window) { 815 # eax = scan-next-byte(_test-buffered-file, _test-error-buffered-file, ed) 816 # . . push args 817 51/push-ecx/ed - 818 68/push _test-error-buffered-file/imm32 + 818 68/push _test-error-buffered-file/imm32 819 68/push _test-buffered-file/imm32 820 # . . call 821 e8/call scan-next-byte/disp32 @@ -982,7 +982,7 @@ if ('onhashchange' in window) { 921 # eax = scan-next-byte(_test-buffered-file, _test-error-buffered-file, ed) 922 # . . push args 923 51/push-ecx/ed - 924 68/push _test-error-buffered-file/imm32 + 924 68/push _test-error-buffered-file/imm32 925 68/push _test-buffered-file/imm32 926 # . . call 927 e8/call scan-next-byte/disp32 @@ -1090,7 +1090,7 @@ if ('onhashchange' in window) { 1029 # eax = scan-next-byte(_test-buffered-file, _test-error-buffered-file, ed) 1030 # . . push args 1031 51/push-ecx/ed -1032 68/push _test-error-buffered-file/imm32 +1032 68/push _test-error-buffered-file/imm32 1033 68/push _test-buffered-file/imm32 1034 # . . call 1035 e8/call scan-next-byte/disp32 @@ -1188,7 +1188,7 @@ if ('onhashchange' in window) { 1127 # eax = scan-next-byte(_test-buffered-file, _test-error-buffered-file, ed) 1128 # . . push args 1129 51/push-ecx/ed -1130 68/push _test-error-buffered-file/imm32 +1130 68/push _test-error-buffered-file/imm32 1131 68/push _test-buffered-file/imm32 1132 # . . call 1133 e8/call scan-next-byte/disp32 @@ -1278,7 +1278,7 @@ if ('onhashchange' in window) { 1217 # eax = scan-next-byte(_test-buffered-file, _test-error-buffered-file, ed) 1218 # . . push args 1219 51/push-ecx/ed -1220 68/push _test-error-buffered-file/imm32 +1220 68/push _test-error-buffered-file/imm32 1221 68/push _test-buffered-file/imm32 1222 # . . call 1223 e8/call scan-next-byte/disp32 @@ -1376,7 +1376,7 @@ if ('onhashchange' in window) { 1315 # eax = scan-next-byte(_test-buffered-file, _test-error-buffered-file, ed) 1316 # . . push args 1317 51/push-ecx/ed -1318 68/push _test-error-buffered-file/imm32 +1318 68/push _test-error-buffered-file/imm32 1319 68/push _test-buffered-file/imm32 1320 # . . call 1321 e8/call scan-next-byte/disp32 diff --git a/html/apps/mu.subx.html b/html/apps/mu.subx.html index 27f7403b..14f7646f 100644 --- a/html/apps/mu.subx.html +++ b/html/apps/mu.subx.html @@ -573,7 +573,7 @@ if ('onhashchange' in window) { 511 # . save registers 512 50/push-eax 513 # initialize global data structures - 514 c7 0/subop/copy *Next-block-index 1/imm32 + 514 c7 0/subop/copy *Next-block-index 1/imm32 515 8b/-> *Primitive-type-ids 0/r32/eax 516 89/<- *Type-id 0/r32/eax # stream-write 517 c7 0/subop/copy *_Program-functions 0/imm32 @@ -583,11 +583,11 @@ if ('onhashchange' in window) { 521 c7 0/subop/copy *_Program-signatures 0/imm32 522 c7 0/subop/copy *_Program-signatures->payload 0/imm32 523 # - 524 (parse-mu *(ebp+8) *(ebp+0x10) *(ebp+0x14)) - 525 (populate-mu-type-sizes *(ebp+0x10) *(ebp+0x14)) + 524 (parse-mu *(ebp+8) *(ebp+0x10) *(ebp+0x14)) + 525 (populate-mu-type-sizes *(ebp+0x10) *(ebp+0x14)) 526 #? (dump-typeinfos "=== typeinfos\n") - 527 (check-mu-types *(ebp+0x10) *(ebp+0x14)) - 528 (emit-subx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) + 527 (check-mu-types *(ebp+0x10) *(ebp+0x14)) + 528 (emit-subx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) 529 $convert-mu:end: 530 # . restore registers 531 58/pop-to-eax @@ -738,12 +738,12 @@ if ('onhashchange' in window) { 691 (write _test-input-stream "fn foo {\n") 692 (write _test-input-stream "}\n") 693 # convert - 694 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 694 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) 695 # registers except esp clobbered at this point 696 # restore ed 697 89/<- %edx 4/r32/esp 698 (flush _test-output-buffered-file) - 699 (flush _test-error-buffered-file) + 699 (flush _test-error-buffered-file) 700 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 706 # check output 707 (check-stream-equal _test-output-stream "" "F - test-function-with-redefined-name: output should be empty") @@ -777,12 +777,12 @@ if ('onhashchange' in window) { 735 (write _test-input-stream "}\n") 736 (write _test-input-stream "sig foo\n") 737 # convert - 738 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 738 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) 739 # registers except esp clobbered at this point 740 # restore ed 741 89/<- %edx 4/r32/esp 742 (flush _test-output-buffered-file) - 743 (flush _test-error-buffered-file) + 743 (flush _test-error-buffered-file) 744 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 750 # check output 751 (check-stream-equal _test-output-stream "" "F - test-function-with-redefined-name-2: output should be empty") @@ -816,12 +816,12 @@ if ('onhashchange' in window) { 779 (write _test-input-stream "fn foo {\n") 780 (write _test-input-stream "}\n") 781 # convert - 782 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 782 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) 783 # registers except esp clobbered at this point 784 # restore ed 785 89/<- %edx 4/r32/esp 786 (flush _test-output-buffered-file) - 787 (flush _test-error-buffered-file) + 787 (flush _test-error-buffered-file) 788 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 794 # check output 795 (check-stream-equal _test-output-stream "" "F - test-function-with-redefined-name-3: output should be empty") @@ -854,12 +854,12 @@ if ('onhashchange' in window) { 822 (write _test-input-stream "fn foo x/eax: int {\n") 823 (write _test-input-stream "}\n") 824 # convert - 825 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 825 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) 826 # registers except esp clobbered at this point 827 # restore ed 828 89/<- %edx 4/r32/esp 829 (flush _test-output-buffered-file) - 830 (flush _test-error-buffered-file) + 830 (flush _test-error-buffered-file) 831 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 837 # check output 838 (check-stream-equal _test-output-stream "" "F - test-function-with-inout-in-register: output should be empty") @@ -872,7 +872,7 @@ if ('onhashchange' in window) { 845 5d/pop-to-ebp 846 c3/return 847 - 848 test-convert-function-with-arg-and-body: + 848 test-function-with-addr-output: 849 # . prologue 850 55/push-ebp 851 89/<- %ebp 4/r32/esp @@ -881,226 +881,231 @@ if ('onhashchange' in window) { 854 (clear-stream $_test-input-buffered-file->buffer) 855 (clear-stream _test-output-stream) 856 (clear-stream $_test-output-buffered-file->buffer) - 857 # - 858 (write _test-input-stream "fn foo n: int {\n") - 859 (write _test-input-stream " increment n\n") - 860 (write _test-input-stream "}\n") - 861 # convert - 862 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 863 (flush _test-output-buffered-file) - 864 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 870 # check output - 871 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-arg-and-body/0") - 872 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-arg-and-body/1") - 873 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-arg-and-body/2") - 874 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-arg-and-body/3") - 875 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-arg-and-body/4") - 876 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-arg-and-body/5") - 877 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-arg-and-body/6") - 878 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-arg-and-body/7") - 879 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-arg-and-body/8") - 880 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-arg-and-body/9") - 881 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-arg-and-body/10") - 882 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-arg-and-body/11") - 883 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-arg-and-body/12") - 884 # . epilogue - 885 89/<- %esp 5/r32/ebp - 886 5d/pop-to-ebp - 887 c3/return - 888 - 889 test-convert-function-distinguishes-args: - 890 # . prologue - 891 55/push-ebp - 892 89/<- %ebp 4/r32/esp - 893 # setup - 894 (clear-stream _test-input-stream) - 895 (clear-stream $_test-input-buffered-file->buffer) - 896 (clear-stream _test-output-stream) - 897 (clear-stream $_test-output-buffered-file->buffer) - 898 # - 899 (write _test-input-stream "fn foo a: int, b: int {\n") - 900 (write _test-input-stream " increment b\n") - 901 (write _test-input-stream "}\n") - 902 # convert - 903 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 904 (flush _test-output-buffered-file) - 905 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 911 # check output - 912 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-distinguishes-args/0") - 913 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-distinguishes-args/1") - 914 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-distinguishes-args/2") - 915 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-distinguishes-args/3") - 916 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-distinguishes-args/4") - 917 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-distinguishes-args/5") - 918 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x0000000c)" "F - test-convert-function-distinguishes-args/6") - 919 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-distinguishes-args/7") - 920 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-distinguishes-args/8") - 921 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-distinguishes-args/9") - 922 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-distinguishes-args/10") - 923 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-distinguishes-args/11") - 924 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-distinguishes-args/12") - 925 # . epilogue - 926 89/<- %esp 5/r32/ebp - 927 5d/pop-to-ebp - 928 c3/return - 929 - 930 test-convert-function-with-return-literal: - 931 # . prologue - 932 55/push-ebp - 933 89/<- %ebp 4/r32/esp - 934 # setup - 935 (clear-stream _test-input-stream) - 936 (clear-stream $_test-input-buffered-file->buffer) - 937 (clear-stream _test-output-stream) - 938 (clear-stream $_test-output-buffered-file->buffer) - 939 # - 940 (write _test-input-stream "fn foo -> _/eax: int {\n") - 941 (write _test-input-stream " return 0\n") - 942 (write _test-input-stream "}\n") - 943 # convert - 944 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 945 (flush _test-output-buffered-file) - 946 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 952 # check output - 953 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-literal/0") - 954 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-literal/1") - 955 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-literal/2") - 956 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-literal/3") - 957 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-literal/4") - 958 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-literal/5") - 959 (check-next-stream-line-equal _test-output-stream " c7 0/subop/copy %eax 0/imm32" "F - test-convert-function-with-return-literal/6") - 960 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-literal/7") - 961 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-literal/8") - 962 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-literal/9") - 963 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-literal/10") - 964 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-literal/11") - 965 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-literal/12") - 966 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-literal/13") - 967 # . epilogue - 968 89/<- %esp 5/r32/ebp - 969 5d/pop-to-ebp - 970 c3/return - 971 - 972 test-convert-function-with-return: - 973 # . prologue - 974 55/push-ebp - 975 89/<- %ebp 4/r32/esp - 976 # setup - 977 (clear-stream _test-input-stream) - 978 (clear-stream $_test-input-buffered-file->buffer) - 979 (clear-stream _test-output-stream) - 980 (clear-stream $_test-output-buffered-file->buffer) - 981 # - 982 (write _test-input-stream "fn foo -> _/eax: int {\n") - 983 (write _test-input-stream " var y: int\n") - 984 (write _test-input-stream " return y\n") - 985 (write _test-input-stream "}\n") - 986 # convert - 987 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 988 (flush _test-output-buffered-file) - 989 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 995 # check output - 996 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return/0") - 997 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return/1") - 998 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return/2") - 999 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return/3") - 1000 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return/4") - 1001 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return/5") - 1002 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-return/6") # y - 1003 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffffc) 0x00000000/r32" "F - test-convert-function-with-return/7") - 1004 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return/8") - 1005 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return/9") - 1006 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return/10") - 1007 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return/11") - 1008 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return/12") - 1009 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return/13") - 1010 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return/14") - 1011 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return/15") - 1012 # . epilogue - 1013 89/<- %esp 5/r32/ebp - 1014 5d/pop-to-ebp - 1015 c3/return - 1016 - 1017 test-convert-function-with-return-register: - 1018 # . prologue - 1019 55/push-ebp - 1020 89/<- %ebp 4/r32/esp - 1021 # setup - 1022 (clear-stream _test-input-stream) - 1023 (clear-stream $_test-input-buffered-file->buffer) - 1024 (clear-stream _test-output-stream) - 1025 (clear-stream $_test-output-buffered-file->buffer) - 1026 # - 1027 (write _test-input-stream "fn foo -> _/eax: int {\n") - 1028 (write _test-input-stream " var y/eax: int <- copy 3\n") - 1029 (write _test-input-stream " return y\n") - 1030 (write _test-input-stream "}\n") - 1031 # convert - 1032 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 1033 (flush _test-output-buffered-file) - 1034 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1040 # check output - 1041 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-register/0") - 1042 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-register/1") - 1043 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-register/2") - 1044 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-register/3") - 1045 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-register/4") - 1046 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-register/5") - 1047 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-register/6") - 1048 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-register/7") - 1049 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-with-return-register/8") - 1050 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-return-register/9") - 1051 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-register/10") - 1052 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-register/11") - 1053 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-register/12") - 1054 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-register/13") - 1055 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-register/14") - 1056 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-register/15") - 1057 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-register/16") - 1058 # . epilogue - 1059 89/<- %esp 5/r32/ebp + 857 (clear-stream _test-error-stream) + 858 (clear-stream $_test-error-buffered-file->buffer) + 859 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 860 68/push 0/imm32 + 861 68/push 0/imm32 + 862 89/<- %edx 4/r32/esp + 863 (tailor-exit-descriptor %edx 0x10) + 864 # + 865 (write _test-input-stream "fn foo -> _/eax: (addr int) {\n") + 866 (write _test-input-stream "}\n") + 867 # convert + 868 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 869 # registers except esp clobbered at this point + 870 # restore ed + 871 89/<- %edx 4/r32/esp + 872 (flush _test-output-buffered-file) + 873 (flush _test-error-buffered-file) + 874 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 880 # check output + 881 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-output: output should be empty") + 882 (check-next-stream-line-equal _test-error-stream "fn foo: output cannot have an addr type; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-output: error message") + 883 # check that stop(1) was called + 884 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-output: exit status") + 885 # don't restore from ebp + 886 81 0/subop/add %esp 8/imm32 + 887 # . epilogue + 888 5d/pop-to-ebp + 889 c3/return + 890 + 891 test-function-with-addr-inout: + 892 # . prologue + 893 55/push-ebp + 894 89/<- %ebp 4/r32/esp + 895 # setup + 896 (clear-stream _test-input-stream) + 897 (clear-stream $_test-input-buffered-file->buffer) + 898 (clear-stream _test-output-stream) + 899 (clear-stream $_test-output-buffered-file->buffer) + 900 (clear-stream _test-error-stream) + 901 (clear-stream $_test-error-buffered-file->buffer) + 902 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 903 68/push 0/imm32 + 904 68/push 0/imm32 + 905 89/<- %edx 4/r32/esp + 906 (tailor-exit-descriptor %edx 0x10) + 907 # + 908 (write _test-input-stream "fn foo a: (addr addr int) {\n") + 909 (write _test-input-stream "}\n") + 910 # convert + 911 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 912 # registers except esp clobbered at this point + 913 # restore ed + 914 89/<- %edx 4/r32/esp + 915 (flush _test-output-buffered-file) + 916 (flush _test-error-buffered-file) + 917 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 923 # check output + 924 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-inout: output should be empty") + 925 (check-next-stream-line-equal _test-error-stream "fn foo: inout 'a' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-inout: error message") + 926 # check that stop(1) was called + 927 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-inout: exit status") + 928 # don't restore from ebp + 929 81 0/subop/add %esp 8/imm32 + 930 # . epilogue + 931 5d/pop-to-ebp + 932 c3/return + 933 + 934 test-function-with-addr-inout-2: + 935 # . prologue + 936 55/push-ebp + 937 89/<- %ebp 4/r32/esp + 938 # setup + 939 (clear-stream _test-input-stream) + 940 (clear-stream $_test-input-buffered-file->buffer) + 941 (clear-stream _test-output-stream) + 942 (clear-stream $_test-output-buffered-file->buffer) + 943 (clear-stream _test-error-stream) + 944 (clear-stream $_test-error-buffered-file->buffer) + 945 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 946 68/push 0/imm32 + 947 68/push 0/imm32 + 948 89/<- %edx 4/r32/esp + 949 (tailor-exit-descriptor %edx 0x10) + 950 # + 951 (write _test-input-stream "fn foo a: (addr array addr int) {\n") + 952 (write _test-input-stream "}\n") + 953 # convert + 954 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 955 # registers except esp clobbered at this point + 956 # restore ed + 957 89/<- %edx 4/r32/esp + 958 (flush _test-output-buffered-file) + 959 (flush _test-error-buffered-file) + 960 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 966 # check output + 967 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-inout-2: output should be empty") + 968 (check-next-stream-line-equal _test-error-stream "fn foo: inout 'a' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-inout-2: error message") + 969 # check that stop(1) was called + 970 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-inout-2: exit status") + 971 # don't restore from ebp + 972 81 0/subop/add %esp 8/imm32 + 973 # . epilogue + 974 5d/pop-to-ebp + 975 c3/return + 976 + 977 test-function-with-addr-inout-3: + 978 # . prologue + 979 55/push-ebp + 980 89/<- %ebp 4/r32/esp + 981 # setup + 982 (clear-stream _test-input-stream) + 983 (clear-stream $_test-input-buffered-file->buffer) + 984 (clear-stream _test-output-stream) + 985 (clear-stream $_test-output-buffered-file->buffer) + 986 (clear-stream _test-error-stream) + 987 (clear-stream $_test-error-buffered-file->buffer) + 988 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 989 68/push 0/imm32 + 990 68/push 0/imm32 + 991 89/<- %edx 4/r32/esp + 992 (tailor-exit-descriptor %edx 0x10) + 993 # + 994 (write _test-input-stream "fn foo a: (addr array (addr int) 3) {\n") + 995 (write _test-input-stream "}\n") + 996 # convert + 997 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 998 # registers except esp clobbered at this point + 999 # restore ed + 1000 89/<- %edx 4/r32/esp + 1001 (flush _test-output-buffered-file) + 1002 (flush _test-error-buffered-file) + 1003 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1009 # check output + 1010 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-inout-3: output should be empty") + 1011 (check-next-stream-line-equal _test-error-stream "fn foo: inout 'a' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-inout-3: error message") + 1012 # check that stop(1) was called + 1013 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-inout-3: exit status") + 1014 # don't restore from ebp + 1015 81 0/subop/add %esp 8/imm32 + 1016 # . epilogue + 1017 5d/pop-to-ebp + 1018 c3/return + 1019 + 1020 test-function-with-addr-inout-4: + 1021 # . prologue + 1022 55/push-ebp + 1023 89/<- %ebp 4/r32/esp + 1024 # setup + 1025 (clear-stream _test-input-stream) + 1026 (clear-stream $_test-input-buffered-file->buffer) + 1027 (clear-stream _test-output-stream) + 1028 (clear-stream $_test-output-buffered-file->buffer) + 1029 (clear-stream _test-error-stream) + 1030 (clear-stream $_test-error-buffered-file->buffer) + 1031 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1032 68/push 0/imm32 + 1033 68/push 0/imm32 + 1034 89/<- %edx 4/r32/esp + 1035 (tailor-exit-descriptor %edx 0x10) + 1036 # + 1037 (write _test-input-stream "fn foo a: (array (addr int) 3) {\n") + 1038 (write _test-input-stream "}\n") + 1039 # convert + 1040 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1041 # registers except esp clobbered at this point + 1042 # restore ed + 1043 89/<- %edx 4/r32/esp + 1044 (flush _test-output-buffered-file) + 1045 (flush _test-error-buffered-file) + 1046 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1052 # check output + 1053 (check-stream-equal _test-output-stream "" "F - test-function-with-addr-inout-4: output should be empty") + 1054 (check-next-stream-line-equal _test-error-stream "fn foo: inout 'a' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function" "F - test-function-with-addr-inout-4: error message") + 1055 # check that stop(1) was called + 1056 (check-ints-equal *(edx+4) 2 "F - test-function-with-addr-inout-4: exit status") + 1057 # don't restore from ebp + 1058 81 0/subop/add %esp 8/imm32 + 1059 # . epilogue 1060 5d/pop-to-ebp 1061 c3/return 1062 - 1063 test-function-with-output-without-register: - 1064 # . prologue - 1065 55/push-ebp - 1066 89/<- %ebp 4/r32/esp - 1067 # setup - 1068 (clear-stream _test-input-stream) - 1069 (clear-stream $_test-input-buffered-file->buffer) - 1070 (clear-stream _test-output-stream) - 1071 (clear-stream $_test-output-buffered-file->buffer) - 1072 (clear-stream _test-error-stream) - 1073 (clear-stream $_test-error-buffered-file->buffer) - 1074 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 1075 68/push 0/imm32 - 1076 68/push 0/imm32 - 1077 89/<- %edx 4/r32/esp - 1078 (tailor-exit-descriptor %edx 0x10) - 1079 # - 1080 (write _test-input-stream "fn foo -> _: int {\n") - 1081 (write _test-input-stream "}\n") - 1082 # convert - 1083 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1084 # registers except esp clobbered at this point - 1085 # restore ed - 1086 89/<- %edx 4/r32/esp - 1087 (flush _test-output-buffered-file) - 1088 (flush _test-error-buffered-file) - 1089 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1095 # check output - 1096 (check-stream-equal _test-output-stream "" "F - test-function-with-output-without-register: output should be empty") - 1097 (check-next-stream-line-equal _test-error-stream "fn foo: function output '_' must be in a register, in instruction 'fn foo -> _: int {" "F - test-function-with-output-without-register: error message") - 1098 # check that stop(1) was called - 1099 (check-ints-equal *(edx+4) 2 "F - test-function-with-output-without-register: exit status") - 1100 # don't restore from ebp - 1101 81 0/subop/add %esp 8/imm32 - 1102 # . epilogue + 1063 # 'main' is an exception + 1064 test-function-main-with-addr-inout: + 1065 # . prologue + 1066 55/push-ebp + 1067 89/<- %ebp 4/r32/esp + 1068 # setup + 1069 (clear-stream _test-input-stream) + 1070 (clear-stream $_test-input-buffered-file->buffer) + 1071 (clear-stream _test-output-stream) + 1072 (clear-stream $_test-output-buffered-file->buffer) + 1073 # + 1074 (write _test-input-stream "fn main a: (addr addr int) {\n") + 1075 (write _test-input-stream "}\n") + 1076 # convert + 1077 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1078 (flush _test-output-buffered-file) + 1079 # no errors + 1080 # . epilogue + 1081 89/<- %esp 5/r32/ebp + 1082 5d/pop-to-ebp + 1083 c3/return + 1084 + 1085 # 'lookup' is an exception, but only in signatures + 1086 test-signature-lookup-with-addr-inout: + 1087 # . prologue + 1088 55/push-ebp + 1089 89/<- %ebp 4/r32/esp + 1090 # setup + 1091 (clear-stream _test-input-stream) + 1092 (clear-stream $_test-input-buffered-file->buffer) + 1093 (clear-stream _test-output-stream) + 1094 (clear-stream $_test-output-buffered-file->buffer) + 1095 # + 1096 (write _test-input-stream "sig lookup h: (handle _T) -> _/eax: (addr _T)\n") + 1097 # convert + 1098 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1099 (flush _test-output-buffered-file) + 1100 # no errors + 1101 # . epilogue + 1102 89/<- %esp 5/r32/ebp 1103 5d/pop-to-ebp 1104 c3/return 1105 - 1106 test-function-with-outputs-in-conflicting-registers: + 1106 test-convert-function-with-arg-and-body: 1107 # . prologue 1108 55/push-ebp 1109 89/<- %ebp 4/r32/esp @@ -1109,593 +1114,583 @@ if ('onhashchange' in window) { 1112 (clear-stream $_test-input-buffered-file->buffer) 1113 (clear-stream _test-output-stream) 1114 (clear-stream $_test-output-buffered-file->buffer) - 1115 (clear-stream _test-error-stream) - 1116 (clear-stream $_test-error-buffered-file->buffer) - 1117 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 1118 68/push 0/imm32 - 1119 68/push 0/imm32 - 1120 89/<- %edx 4/r32/esp - 1121 (tailor-exit-descriptor %edx 0x10) - 1122 # - 1123 (write _test-input-stream "fn foo -> _/eax: int, _/eax: int {\n") - 1124 (write _test-input-stream "}\n") - 1125 # convert - 1126 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1127 # registers except esp clobbered at this point - 1128 # restore ed - 1129 89/<- %edx 4/r32/esp - 1130 (flush _test-output-buffered-file) - 1131 (flush _test-error-buffered-file) - 1132 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1138 # check output - 1139 (check-stream-equal _test-output-stream "" "F - test-function-with-outputs-in-conflicting-registers: output should be empty") - 1140 (check-next-stream-line-equal _test-error-stream "fn foo: outputs must be in unique registers" "F - test-function-with-outputs-in-conflicting-registers: error message") - 1141 # check that stop(1) was called - 1142 (check-ints-equal *(edx+4) 2 "F - test-function-with-outputs-in-conflicting-registers: exit status") - 1143 # don't restore from ebp - 1144 81 0/subop/add %esp 8/imm32 - 1145 # . epilogue - 1146 5d/pop-to-ebp - 1147 c3/return - 1148 - 1149 test-function-with-named-output: - 1150 # . prologue - 1151 55/push-ebp - 1152 89/<- %ebp 4/r32/esp - 1153 # setup - 1154 (clear-stream _test-input-stream) - 1155 (clear-stream $_test-input-buffered-file->buffer) - 1156 (clear-stream _test-output-stream) - 1157 (clear-stream $_test-output-buffered-file->buffer) - 1158 (clear-stream _test-error-stream) - 1159 (clear-stream $_test-error-buffered-file->buffer) - 1160 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 1161 68/push 0/imm32 - 1162 68/push 0/imm32 - 1163 89/<- %edx 4/r32/esp - 1164 (tailor-exit-descriptor %edx 0x10) - 1165 # - 1166 (write _test-input-stream "fn foo -> x/eax: int {\n") - 1167 (write _test-input-stream " return 0\n") - 1168 (write _test-input-stream "}\n") - 1169 # convert - 1170 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1171 # registers except esp clobbered at this point - 1172 # restore ed - 1173 89/<- %edx 4/r32/esp - 1174 (flush _test-output-buffered-file) - 1175 (flush _test-error-buffered-file) - 1176 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1182 # check output - 1183 (check-stream-equal _test-output-stream "" "F - test-function-with-named-output: output should be empty") - 1184 (check-next-stream-line-equal _test-error-stream "fn foo: function outputs cannot be named; rename 'x' in the header to '_'" "F - test-function-with-named-output: error message") - 1185 # check that stop(1) was called - 1186 (check-ints-equal *(edx+4) 2 "F - test-function-with-named-output: exit status") - 1187 # don't restore from ebp - 1188 81 0/subop/add %esp 8/imm32 - 1189 # . epilogue - 1190 5d/pop-to-ebp - 1191 c3/return - 1192 - 1193 test-return-with-wrong-type: - 1194 # . prologue - 1195 55/push-ebp - 1196 89/<- %ebp 4/r32/esp - 1197 # setup - 1198 (clear-stream _test-input-stream) - 1199 (clear-stream $_test-input-buffered-file->buffer) - 1200 (clear-stream _test-output-stream) - 1201 (clear-stream $_test-output-buffered-file->buffer) - 1202 (clear-stream _test-error-stream) - 1203 (clear-stream $_test-error-buffered-file->buffer) - 1204 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 1205 68/push 0/imm32 - 1206 68/push 0/imm32 - 1207 89/<- %edx 4/r32/esp - 1208 (tailor-exit-descriptor %edx 0x10) - 1209 # - 1210 (write _test-input-stream "fn foo -> _/eax: int {\n") - 1211 (write _test-input-stream " var x/eax: boolean <- copy 0\n") - 1212 (write _test-input-stream " return x\n") - 1213 (write _test-input-stream "}\n") - 1214 # convert - 1215 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1216 # registers except esp clobbered at this point - 1217 # restore ed - 1218 89/<- %edx 4/r32/esp - 1219 (flush _test-output-buffered-file) - 1220 (flush _test-error-buffered-file) - 1221 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1227 # check output - 1228 (check-stream-equal _test-output-stream "" "F - test-return-with-wrong-type: output should be empty") - 1229 (check-next-stream-line-equal _test-error-stream "fn foo: return: 'x' has the wrong type" "F - test-return-with-wrong-type: error message") - 1230 # check that stop(1) was called - 1231 (check-ints-equal *(edx+4) 2 "F - test-return-with-wrong-type: exit status") - 1232 # don't restore from ebp - 1233 81 0/subop/add %esp 8/imm32 - 1234 # . epilogue - 1235 5d/pop-to-ebp - 1236 c3/return - 1237 - 1238 test-missing-return: - 1239 # . prologue - 1240 55/push-ebp - 1241 89/<- %ebp 4/r32/esp - 1242 # setup - 1243 (clear-stream _test-input-stream) - 1244 (clear-stream $_test-input-buffered-file->buffer) - 1245 (clear-stream _test-output-stream) - 1246 (clear-stream $_test-output-buffered-file->buffer) - 1247 (clear-stream _test-error-stream) - 1248 (clear-stream $_test-error-buffered-file->buffer) - 1249 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 1250 68/push 0/imm32 - 1251 68/push 0/imm32 - 1252 89/<- %edx 4/r32/esp - 1253 (tailor-exit-descriptor %edx 0x10) - 1254 # - 1255 (write _test-input-stream "fn foo -> _/eax: int {\n") - 1256 (write _test-input-stream " var x/eax: boolean <- copy 0\n") - 1257 (write _test-input-stream "}\n") - 1258 # convert - 1259 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1260 # registers except esp clobbered at this point - 1261 # restore ed - 1262 89/<- %edx 4/r32/esp - 1263 (flush _test-output-buffered-file) - 1264 (flush _test-error-buffered-file) - 1265 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1271 # check output - 1272 (check-stream-equal _test-output-stream "" "F - test-missing-return: output should be empty") - 1273 (check-next-stream-line-equal _test-error-stream "fn foo: final statement should be a 'return'" "F - test-missing-return: error message") - 1274 # check that stop(1) was called - 1275 (check-ints-equal *(edx+4) 2 "F - test-missing-return: exit status") - 1276 # don't restore from ebp - 1277 81 0/subop/add %esp 8/imm32 - 1278 # . epilogue - 1279 5d/pop-to-ebp - 1280 c3/return - 1281 - 1282 test-early-exit-without-return: - 1283 # . prologue - 1284 55/push-ebp - 1285 89/<- %ebp 4/r32/esp - 1286 # setup - 1287 (clear-stream _test-input-stream) - 1288 (clear-stream $_test-input-buffered-file->buffer) - 1289 (clear-stream _test-output-stream) - 1290 (clear-stream $_test-output-buffered-file->buffer) - 1291 (clear-stream _test-error-stream) - 1292 (clear-stream $_test-error-buffered-file->buffer) - 1293 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 1294 68/push 0/imm32 - 1295 68/push 0/imm32 - 1296 89/<- %edx 4/r32/esp - 1297 (tailor-exit-descriptor %edx 0x10) - 1298 # - 1299 (write _test-input-stream "fn foo -> _/eax: int {\n") - 1300 (write _test-input-stream " break\n") - 1301 (write _test-input-stream " return 0\n") - 1302 (write _test-input-stream "}\n") - 1303 # convert - 1304 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1305 # registers except esp clobbered at this point - 1306 # restore ed - 1307 89/<- %edx 4/r32/esp - 1308 (flush _test-output-buffered-file) - 1309 (flush _test-error-buffered-file) - 1310 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1316 # check output - 1317 (check-stream-equal _test-output-stream "" "F - test-early-exit-without-return: output should be empty") - 1318 (check-next-stream-line-equal _test-error-stream "fn foo has outputs, so you cannot 'break' out of the outermost block. Use 'return'." "F - test-early-exit-without-return: error message") - 1319 # check that stop(1) was called - 1320 (check-ints-equal *(edx+4) 2 "F - test-early-exit-without-return: exit status") - 1321 # don't restore from ebp - 1322 81 0/subop/add %esp 8/imm32 - 1323 # . epilogue - 1324 5d/pop-to-ebp - 1325 c3/return - 1326 - 1327 test-return-with-too-few-inouts: - 1328 # . prologue - 1329 55/push-ebp - 1330 89/<- %ebp 4/r32/esp - 1331 # setup - 1332 (clear-stream _test-input-stream) - 1333 (clear-stream $_test-input-buffered-file->buffer) - 1334 (clear-stream _test-output-stream) - 1335 (clear-stream $_test-output-buffered-file->buffer) - 1336 (clear-stream _test-error-stream) - 1337 (clear-stream $_test-error-buffered-file->buffer) - 1338 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 1339 68/push 0/imm32 - 1340 68/push 0/imm32 - 1341 89/<- %edx 4/r32/esp - 1342 (tailor-exit-descriptor %edx 0x10) - 1343 # - 1344 (write _test-input-stream "fn foo -> _/eax: int {\n") - 1345 (write _test-input-stream " return\n") - 1346 (write _test-input-stream "}\n") - 1347 # convert - 1348 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1349 # registers except esp clobbered at this point - 1350 # restore ed - 1351 89/<- %edx 4/r32/esp - 1352 (flush _test-output-buffered-file) - 1353 (flush _test-error-buffered-file) - 1354 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1360 # check output - 1361 (check-stream-equal _test-output-stream "" "F - test-return-with-too-few-inouts: output should be empty") - 1362 (check-next-stream-line-equal _test-error-stream "fn foo: return: too few inouts" "F - test-return-with-too-few-inouts: error message") - 1363 # check that stop(1) was called - 1364 (check-ints-equal *(edx+4) 2 "F - test-return-with-too-few-inouts: exit status") - 1365 # don't restore from ebp - 1366 81 0/subop/add %esp 8/imm32 - 1367 # . epilogue - 1368 5d/pop-to-ebp - 1369 c3/return - 1370 - 1371 test-return-with-too-many-inouts: - 1372 # . prologue - 1373 55/push-ebp - 1374 89/<- %ebp 4/r32/esp - 1375 # setup - 1376 (clear-stream _test-input-stream) - 1377 (clear-stream $_test-input-buffered-file->buffer) - 1378 (clear-stream _test-output-stream) - 1379 (clear-stream $_test-output-buffered-file->buffer) - 1380 (clear-stream _test-error-stream) - 1381 (clear-stream $_test-error-buffered-file->buffer) - 1382 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 1383 68/push 0/imm32 - 1384 68/push 0/imm32 - 1385 89/<- %edx 4/r32/esp - 1386 (tailor-exit-descriptor %edx 0x10) - 1387 # - 1388 (write _test-input-stream "fn foo -> _/eax: int {\n") - 1389 (write _test-input-stream " return 0, 0\n") - 1390 (write _test-input-stream "}\n") - 1391 # convert - 1392 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1393 # registers except esp clobbered at this point - 1394 # restore ed - 1395 89/<- %edx 4/r32/esp - 1396 (flush _test-output-buffered-file) - 1397 (flush _test-error-buffered-file) - 1398 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1404 # check output - 1405 (check-stream-equal _test-output-stream "" "F - test-return-with-too-many-inouts: output should be empty") - 1406 (check-next-stream-line-equal _test-error-stream "fn foo: return: too many inouts" "F - test-return-with-too-many-inouts: error message") - 1407 # check that stop(1) was called - 1408 (check-ints-equal *(edx+4) 2 "F - test-return-with-too-many-inouts: exit status") - 1409 # don't restore from ebp - 1410 81 0/subop/add %esp 8/imm32 - 1411 # . epilogue - 1412 5d/pop-to-ebp - 1413 c3/return - 1414 - 1415 test-return-unavailable-value: - 1416 # . prologue - 1417 55/push-ebp - 1418 89/<- %ebp 4/r32/esp - 1419 # setup - 1420 (clear-stream _test-input-stream) - 1421 (clear-stream $_test-input-buffered-file->buffer) - 1422 (clear-stream _test-output-stream) - 1423 (clear-stream $_test-output-buffered-file->buffer) - 1424 (clear-stream _test-error-stream) - 1425 (clear-stream $_test-error-buffered-file->buffer) - 1426 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 1427 68/push 0/imm32 - 1428 68/push 0/imm32 - 1429 89/<- %edx 4/r32/esp - 1430 (tailor-exit-descriptor %edx 0x10) - 1431 # - 1432 (write _test-input-stream "fn foo -> _/eax: int, _/ecx: int {\n") - 1433 (write _test-input-stream " var x/eax: int <- copy 0\n") - 1434 (write _test-input-stream " var y/ecx: int <- copy 0\n") - 1435 (write _test-input-stream " return y, x\n") - 1436 (write _test-input-stream "}\n") - 1437 # convert - 1438 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1439 # registers except esp clobbered at this point - 1440 # restore ed - 1441 89/<- %edx 4/r32/esp - 1442 (flush _test-output-buffered-file) - 1443 (flush _test-error-buffered-file) - 1444 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1450 # check output - 1451 (check-stream-equal _test-output-stream "" "F - test-return-unavailable-value: output should be empty") - 1452 (check-next-stream-line-equal _test-error-stream "fn foo: return: 'x' is no longer available" "F - test-return-unavailable-value: error message") - 1453 # check that stop(1) was called - 1454 (check-ints-equal *(edx+4) 2 "F - test-return-unavailable-value: exit status") - 1455 # don't restore from ebp - 1456 81 0/subop/add %esp 8/imm32 - 1457 # . epilogue - 1458 5d/pop-to-ebp - 1459 c3/return - 1460 - 1461 test-convert-return-with-duplicate-values: - 1462 # . prologue - 1463 55/push-ebp - 1464 89/<- %ebp 4/r32/esp - 1465 # setup - 1466 (clear-stream _test-input-stream) - 1467 (clear-stream $_test-input-buffered-file->buffer) - 1468 (clear-stream _test-output-stream) - 1469 (clear-stream $_test-output-buffered-file->buffer) - 1470 # - 1471 (write _test-input-stream "fn foo -> _/eax: int, _/ecx: int {\n") - 1472 (write _test-input-stream " var x/eax: int <- copy 0x34\n") - 1473 (write _test-input-stream " return x, x\n") - 1474 (write _test-input-stream "}\n") - 1475 # convert - 1476 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1115 # + 1116 (write _test-input-stream "fn foo n: int {\n") + 1117 (write _test-input-stream " increment n\n") + 1118 (write _test-input-stream "}\n") + 1119 # convert + 1120 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1121 (flush _test-output-buffered-file) + 1122 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1128 # check output + 1129 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-arg-and-body/0") + 1130 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-arg-and-body/1") + 1131 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-arg-and-body/2") + 1132 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-arg-and-body/3") + 1133 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-arg-and-body/4") + 1134 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-arg-and-body/5") + 1135 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-arg-and-body/6") + 1136 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-arg-and-body/7") + 1137 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-arg-and-body/8") + 1138 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-arg-and-body/9") + 1139 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-arg-and-body/10") + 1140 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-arg-and-body/11") + 1141 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-arg-and-body/12") + 1142 # . epilogue + 1143 89/<- %esp 5/r32/ebp + 1144 5d/pop-to-ebp + 1145 c3/return + 1146 + 1147 test-convert-function-distinguishes-args: + 1148 # . prologue + 1149 55/push-ebp + 1150 89/<- %ebp 4/r32/esp + 1151 # setup + 1152 (clear-stream _test-input-stream) + 1153 (clear-stream $_test-input-buffered-file->buffer) + 1154 (clear-stream _test-output-stream) + 1155 (clear-stream $_test-output-buffered-file->buffer) + 1156 # + 1157 (write _test-input-stream "fn foo a: int, b: int {\n") + 1158 (write _test-input-stream " increment b\n") + 1159 (write _test-input-stream "}\n") + 1160 # convert + 1161 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1162 (flush _test-output-buffered-file) + 1163 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1169 # check output + 1170 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-distinguishes-args/0") + 1171 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-distinguishes-args/1") + 1172 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-distinguishes-args/2") + 1173 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-distinguishes-args/3") + 1174 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-distinguishes-args/4") + 1175 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-distinguishes-args/5") + 1176 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x0000000c)" "F - test-convert-function-distinguishes-args/6") + 1177 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-distinguishes-args/7") + 1178 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-distinguishes-args/8") + 1179 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-distinguishes-args/9") + 1180 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-distinguishes-args/10") + 1181 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-distinguishes-args/11") + 1182 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-distinguishes-args/12") + 1183 # . epilogue + 1184 89/<- %esp 5/r32/ebp + 1185 5d/pop-to-ebp + 1186 c3/return + 1187 + 1188 test-convert-function-with-return-literal: + 1189 # . prologue + 1190 55/push-ebp + 1191 89/<- %ebp 4/r32/esp + 1192 # setup + 1193 (clear-stream _test-input-stream) + 1194 (clear-stream $_test-input-buffered-file->buffer) + 1195 (clear-stream _test-output-stream) + 1196 (clear-stream $_test-output-buffered-file->buffer) + 1197 # + 1198 (write _test-input-stream "fn foo -> _/eax: int {\n") + 1199 (write _test-input-stream " return 0\n") + 1200 (write _test-input-stream "}\n") + 1201 # convert + 1202 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1203 (flush _test-output-buffered-file) + 1204 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1210 # check output + 1211 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-literal/0") + 1212 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-literal/1") + 1213 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-literal/2") + 1214 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-literal/3") + 1215 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-literal/4") + 1216 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-literal/5") + 1217 (check-next-stream-line-equal _test-output-stream " c7 0/subop/copy %eax 0/imm32" "F - test-convert-function-with-return-literal/6") + 1218 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-literal/7") + 1219 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-literal/8") + 1220 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-literal/9") + 1221 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-literal/10") + 1222 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-literal/11") + 1223 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-literal/12") + 1224 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-literal/13") + 1225 # . epilogue + 1226 89/<- %esp 5/r32/ebp + 1227 5d/pop-to-ebp + 1228 c3/return + 1229 + 1230 test-convert-function-with-return: + 1231 # . prologue + 1232 55/push-ebp + 1233 89/<- %ebp 4/r32/esp + 1234 # setup + 1235 (clear-stream _test-input-stream) + 1236 (clear-stream $_test-input-buffered-file->buffer) + 1237 (clear-stream _test-output-stream) + 1238 (clear-stream $_test-output-buffered-file->buffer) + 1239 # + 1240 (write _test-input-stream "fn foo -> _/eax: int {\n") + 1241 (write _test-input-stream " var y: int\n") + 1242 (write _test-input-stream " return y\n") + 1243 (write _test-input-stream "}\n") + 1244 # convert + 1245 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1246 (flush _test-output-buffered-file) + 1247 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1253 # check output + 1254 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return/0") + 1255 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return/1") + 1256 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return/2") + 1257 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return/3") + 1258 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return/4") + 1259 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return/5") + 1260 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-return/6") # y + 1261 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffffc) 0x00000000/r32" "F - test-convert-function-with-return/7") + 1262 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return/8") + 1263 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return/9") + 1264 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return/10") + 1265 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return/11") + 1266 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return/12") + 1267 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return/13") + 1268 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return/14") + 1269 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return/15") + 1270 # . epilogue + 1271 89/<- %esp 5/r32/ebp + 1272 5d/pop-to-ebp + 1273 c3/return + 1274 + 1275 test-convert-function-with-return-register: + 1276 # . prologue + 1277 55/push-ebp + 1278 89/<- %ebp 4/r32/esp + 1279 # setup + 1280 (clear-stream _test-input-stream) + 1281 (clear-stream $_test-input-buffered-file->buffer) + 1282 (clear-stream _test-output-stream) + 1283 (clear-stream $_test-output-buffered-file->buffer) + 1284 # + 1285 (write _test-input-stream "fn foo -> _/eax: int {\n") + 1286 (write _test-input-stream " var y/eax: int <- copy 3\n") + 1287 (write _test-input-stream " return y\n") + 1288 (write _test-input-stream "}\n") + 1289 # convert + 1290 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1291 (flush _test-output-buffered-file) + 1292 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1298 # check output + 1299 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-register/0") + 1300 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-register/1") + 1301 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-register/2") + 1302 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-register/3") + 1303 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-register/4") + 1304 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-register/5") + 1305 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-register/6") + 1306 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-register/7") + 1307 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-with-return-register/8") + 1308 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-return-register/9") + 1309 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-register/10") + 1310 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-register/11") + 1311 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-register/12") + 1312 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-register/13") + 1313 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-register/14") + 1314 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-register/15") + 1315 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-register/16") + 1316 # . epilogue + 1317 89/<- %esp 5/r32/ebp + 1318 5d/pop-to-ebp + 1319 c3/return + 1320 + 1321 test-function-with-output-without-register: + 1322 # . prologue + 1323 55/push-ebp + 1324 89/<- %ebp 4/r32/esp + 1325 # setup + 1326 (clear-stream _test-input-stream) + 1327 (clear-stream $_test-input-buffered-file->buffer) + 1328 (clear-stream _test-output-stream) + 1329 (clear-stream $_test-output-buffered-file->buffer) + 1330 (clear-stream _test-error-stream) + 1331 (clear-stream $_test-error-buffered-file->buffer) + 1332 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1333 68/push 0/imm32 + 1334 68/push 0/imm32 + 1335 89/<- %edx 4/r32/esp + 1336 (tailor-exit-descriptor %edx 0x10) + 1337 # + 1338 (write _test-input-stream "fn foo -> _: int {\n") + 1339 (write _test-input-stream "}\n") + 1340 # convert + 1341 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1342 # registers except esp clobbered at this point + 1343 # restore ed + 1344 89/<- %edx 4/r32/esp + 1345 (flush _test-output-buffered-file) + 1346 (flush _test-error-buffered-file) + 1347 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1353 # check output + 1354 (check-stream-equal _test-output-stream "" "F - test-function-with-output-without-register: output should be empty") + 1355 (check-next-stream-line-equal _test-error-stream "fn foo: function output '_' must be in a register, in instruction 'fn foo -> _: int {" "F - test-function-with-output-without-register: error message") + 1356 # check that stop(1) was called + 1357 (check-ints-equal *(edx+4) 2 "F - test-function-with-output-without-register: exit status") + 1358 # don't restore from ebp + 1359 81 0/subop/add %esp 8/imm32 + 1360 # . epilogue + 1361 5d/pop-to-ebp + 1362 c3/return + 1363 + 1364 test-function-with-outputs-in-conflicting-registers: + 1365 # . prologue + 1366 55/push-ebp + 1367 89/<- %ebp 4/r32/esp + 1368 # setup + 1369 (clear-stream _test-input-stream) + 1370 (clear-stream $_test-input-buffered-file->buffer) + 1371 (clear-stream _test-output-stream) + 1372 (clear-stream $_test-output-buffered-file->buffer) + 1373 (clear-stream _test-error-stream) + 1374 (clear-stream $_test-error-buffered-file->buffer) + 1375 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1376 68/push 0/imm32 + 1377 68/push 0/imm32 + 1378 89/<- %edx 4/r32/esp + 1379 (tailor-exit-descriptor %edx 0x10) + 1380 # + 1381 (write _test-input-stream "fn foo -> _/eax: int, _/eax: int {\n") + 1382 (write _test-input-stream "}\n") + 1383 # convert + 1384 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1385 # registers except esp clobbered at this point + 1386 # restore ed + 1387 89/<- %edx 4/r32/esp + 1388 (flush _test-output-buffered-file) + 1389 (flush _test-error-buffered-file) + 1390 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1396 # check output + 1397 (check-stream-equal _test-output-stream "" "F - test-function-with-outputs-in-conflicting-registers: output should be empty") + 1398 (check-next-stream-line-equal _test-error-stream "fn foo: outputs must be in unique registers" "F - test-function-with-outputs-in-conflicting-registers: error message") + 1399 # check that stop(1) was called + 1400 (check-ints-equal *(edx+4) 2 "F - test-function-with-outputs-in-conflicting-registers: exit status") + 1401 # don't restore from ebp + 1402 81 0/subop/add %esp 8/imm32 + 1403 # . epilogue + 1404 5d/pop-to-ebp + 1405 c3/return + 1406 + 1407 test-function-with-named-output: + 1408 # . prologue + 1409 55/push-ebp + 1410 89/<- %ebp 4/r32/esp + 1411 # setup + 1412 (clear-stream _test-input-stream) + 1413 (clear-stream $_test-input-buffered-file->buffer) + 1414 (clear-stream _test-output-stream) + 1415 (clear-stream $_test-output-buffered-file->buffer) + 1416 (clear-stream _test-error-stream) + 1417 (clear-stream $_test-error-buffered-file->buffer) + 1418 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1419 68/push 0/imm32 + 1420 68/push 0/imm32 + 1421 89/<- %edx 4/r32/esp + 1422 (tailor-exit-descriptor %edx 0x10) + 1423 # + 1424 (write _test-input-stream "fn foo -> x/eax: int {\n") + 1425 (write _test-input-stream " return 0\n") + 1426 (write _test-input-stream "}\n") + 1427 # convert + 1428 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1429 # registers except esp clobbered at this point + 1430 # restore ed + 1431 89/<- %edx 4/r32/esp + 1432 (flush _test-output-buffered-file) + 1433 (flush _test-error-buffered-file) + 1434 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1440 # check output + 1441 (check-stream-equal _test-output-stream "" "F - test-function-with-named-output: output should be empty") + 1442 (check-next-stream-line-equal _test-error-stream "fn foo: function outputs cannot be named; rename 'x' in the header to '_'" "F - test-function-with-named-output: error message") + 1443 # check that stop(1) was called + 1444 (check-ints-equal *(edx+4) 2 "F - test-function-with-named-output: exit status") + 1445 # don't restore from ebp + 1446 81 0/subop/add %esp 8/imm32 + 1447 # . epilogue + 1448 5d/pop-to-ebp + 1449 c3/return + 1450 + 1451 test-return-with-wrong-type: + 1452 # . prologue + 1453 55/push-ebp + 1454 89/<- %ebp 4/r32/esp + 1455 # setup + 1456 (clear-stream _test-input-stream) + 1457 (clear-stream $_test-input-buffered-file->buffer) + 1458 (clear-stream _test-output-stream) + 1459 (clear-stream $_test-output-buffered-file->buffer) + 1460 (clear-stream _test-error-stream) + 1461 (clear-stream $_test-error-buffered-file->buffer) + 1462 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1463 68/push 0/imm32 + 1464 68/push 0/imm32 + 1465 89/<- %edx 4/r32/esp + 1466 (tailor-exit-descriptor %edx 0x10) + 1467 # + 1468 (write _test-input-stream "fn foo -> _/eax: int {\n") + 1469 (write _test-input-stream " var x/eax: boolean <- copy 0\n") + 1470 (write _test-input-stream " return x\n") + 1471 (write _test-input-stream "}\n") + 1472 # convert + 1473 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1474 # registers except esp clobbered at this point + 1475 # restore ed + 1476 89/<- %edx 4/r32/esp 1477 (flush _test-output-buffered-file) - 1478 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1484 # check output - 1485 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-return-with-duplicate-values/0") - 1486 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-return-with-duplicate-values/1") - 1487 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-return-with-duplicate-values/2") - 1488 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-return-with-duplicate-values/3") - 1489 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-return-with-duplicate-values/4") - 1490 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-return-with-duplicate-values/5") - 1491 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-return-with-duplicate-values/6") - 1492 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0x34/imm32" "F - test-convert-return-with-duplicate-values/7") - 1493 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-return-with-duplicate-values/8") - 1494 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000001/r32" "F - test-convert-return-with-duplicate-values/9") - 1495 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-return-with-duplicate-values/10") - 1496 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-return-with-duplicate-values/11") - 1497 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-return-with-duplicate-values/12") - 1498 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-return-with-duplicate-values/13") - 1499 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-return-with-duplicate-values/14") - 1500 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-return-with-duplicate-values/15") - 1501 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-return-with-duplicate-values/16") - 1502 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-return-with-duplicate-values/17") - 1503 # . epilogue - 1504 89/<- %esp 5/r32/ebp - 1505 5d/pop-to-ebp - 1506 c3/return - 1507 - 1508 test-convert-return-with-duplicate-values-2: - 1509 # . prologue - 1510 55/push-ebp - 1511 89/<- %ebp 4/r32/esp - 1512 # setup - 1513 (clear-stream _test-input-stream) - 1514 (clear-stream $_test-input-buffered-file->buffer) - 1515 (clear-stream _test-output-stream) - 1516 (clear-stream $_test-output-buffered-file->buffer) - 1517 # - 1518 (write _test-input-stream "fn foo -> _/eax: int, _/ecx: int {\n") - 1519 (write _test-input-stream " var x/ecx: int <- copy 0x34\n") - 1520 (write _test-input-stream " return x, x\n") - 1521 (write _test-input-stream "}\n") - 1522 # convert - 1523 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 1524 (flush _test-output-buffered-file) - 1525 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1531 # check output - 1532 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-return-with-duplicate-values-2/0") - 1533 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-return-with-duplicate-values-2/1") - 1534 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-return-with-duplicate-values-2/2") - 1535 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-return-with-duplicate-values-2/3") - 1536 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-return-with-duplicate-values-2/4") - 1537 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-return-with-duplicate-values-2/5") - 1538 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-return-with-duplicate-values-2/6") - 1539 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x34/imm32" "F - test-convert-return-with-duplicate-values-2/7") - 1540 (check-next-stream-line-equal _test-output-stream " 8b/-> %ecx 0x00000000/r32" "F - test-convert-return-with-duplicate-values-2/8") - 1541 (check-next-stream-line-equal _test-output-stream " 8b/-> %ecx 0x00000001/r32" "F - test-convert-return-with-duplicate-values-2/9") - 1542 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-return-with-duplicate-values-2/10") - 1543 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-return-with-duplicate-values-2/11") - 1544 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-return-with-duplicate-values-2/12") - 1545 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-return-with-duplicate-values-2/13") - 1546 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-return-with-duplicate-values-2/14") - 1547 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-return-with-duplicate-values-2/15") - 1548 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-return-with-duplicate-values-2/16") - 1549 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-return-with-duplicate-values-2/17") - 1550 # . epilogue - 1551 89/<- %esp 5/r32/ebp - 1552 5d/pop-to-ebp - 1553 c3/return - 1554 - 1555 test-convert-function-with-literal-arg: - 1556 # . prologue - 1557 55/push-ebp - 1558 89/<- %ebp 4/r32/esp - 1559 # setup - 1560 (clear-stream _test-input-stream) - 1561 (clear-stream $_test-input-buffered-file->buffer) - 1562 (clear-stream _test-output-stream) - 1563 (clear-stream $_test-output-buffered-file->buffer) - 1564 # - 1565 (write _test-input-stream "fn foo a: int, b: int -> _/eax: int {\n") - 1566 (write _test-input-stream " var result/eax: int <- copy a\n") - 1567 (write _test-input-stream " result <- add 1\n") - 1568 (write _test-input-stream " return result\n") - 1569 (write _test-input-stream "}\n") - 1570 # convert - 1571 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 1572 (flush _test-output-buffered-file) - 1573 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1579 # check output - 1580 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg/0") - 1581 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg/1") - 1582 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-literal-arg/2") - 1583 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-literal-arg/3") - 1584 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-literal-arg/4") - 1585 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-literal-arg/5") - 1586 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-literal-arg/6") - 1587 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-with-literal-arg/7") - 1588 (check-next-stream-line-equal _test-output-stream " 05/add-to-eax 1/imm32" "F - test-convert-function-with-literal-arg/8") - 1589 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-with-literal-arg/9") - 1590 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-literal-arg/10") - 1591 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-literal-arg/11") - 1592 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-literal-arg/12") - 1593 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-literal-arg/13") - 1594 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-literal-arg/14") - 1595 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-literal-arg/15") - 1596 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-literal-arg/16") - 1597 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-literal-arg/17") - 1598 # . epilogue - 1599 89/<- %esp 5/r32/ebp - 1600 5d/pop-to-ebp - 1601 c3/return - 1602 - 1603 test-convert-function-with-literal-arg-2: - 1604 # . prologue - 1605 55/push-ebp - 1606 89/<- %ebp 4/r32/esp - 1607 # setup - 1608 (clear-stream _test-input-stream) - 1609 (clear-stream $_test-input-buffered-file->buffer) - 1610 (clear-stream _test-output-stream) - 1611 (clear-stream $_test-output-buffered-file->buffer) - 1612 # - 1613 (write _test-input-stream "fn foo a: int, b: int -> _/ebx: int {\n") - 1614 (write _test-input-stream " var result/ebx: int <- copy a\n") - 1615 (write _test-input-stream " result <- add 1\n") - 1616 (write _test-input-stream " return result\n") - 1617 (write _test-input-stream "}\n") - 1618 # convert - 1619 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 1620 (flush _test-output-buffered-file) - 1621 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1627 # check output - 1628 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg-2/0") - 1629 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg-2/1") - 1630 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-literal-arg-2/2") - 1631 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-literal-arg-2/3") - 1632 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-literal-arg-2/4") - 1633 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-literal-arg-2/5") - 1634 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-function-with-literal-arg-2/6") - 1635 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000003/r32" "F - test-convert-function-with-literal-arg-2/7") - 1636 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %ebx 1/imm32" "F - test-convert-function-with-literal-arg-2/8") - 1637 (check-next-stream-line-equal _test-output-stream " 8b/-> %ebx 0x00000003/r32" "F - test-convert-function-with-literal-arg-2/9") - 1638 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-literal-arg-2/10") - 1639 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-literal-arg-2/11") - 1640 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-literal-arg-2/12") - 1641 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-literal-arg-2/13") - 1642 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-literal-arg-2/14") - 1643 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-literal-arg-2/15") - 1644 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-literal-arg-2/16") - 1645 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-literal-arg-2/17") - 1646 # . epilogue - 1647 89/<- %esp 5/r32/ebp - 1648 5d/pop-to-ebp - 1649 c3/return - 1650 - 1651 test-convert-function-call-with-literal-arg: - 1652 # . prologue - 1653 55/push-ebp - 1654 89/<- %ebp 4/r32/esp - 1655 # setup - 1656 (clear-stream _test-input-stream) - 1657 (clear-stream $_test-input-buffered-file->buffer) - 1658 (clear-stream _test-output-stream) - 1659 (clear-stream $_test-output-buffered-file->buffer) - 1660 # - 1661 (write _test-input-stream "fn main -> _/ebx: int {\n") - 1662 (write _test-input-stream " var result/eax: int <- do-add 3 4\n") - 1663 (write _test-input-stream " return result\n") - 1664 (write _test-input-stream "}\n") - 1665 (write _test-input-stream "fn do-add a: int, b: int -> _/eax: int {\n") - 1666 (write _test-input-stream " var result/eax: int <- copy a\n") - 1667 (write _test-input-stream " result <- add b\n") - 1668 (write _test-input-stream " return result\n") - 1669 (write _test-input-stream "}\n") - 1670 # convert - 1671 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 1672 (flush _test-output-buffered-file) - 1673 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1679 # check output - 1680 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call-with-literal-arg/0") - 1681 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-literal-arg/1") - 1682 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-literal-arg/2") - 1683 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-literal-arg/3") - 1684 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-literal-arg/4") - 1685 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:loop:" "F - test-convert-function-call-with-literal-arg/5") - 1686 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-literal-arg/6") - 1687 (check-next-stream-line-equal _test-output-stream " (do-add 3 4)" "F - test-convert-function-call-with-literal-arg/7") - 1688 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8") - 1689 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-local-var-in-reg/9") - 1690 (check-next-stream-line-equal _test-output-stream " e9/jump $main:0x00000001:break/disp32" "F - test-convert-function-call-with-literal-arg/10") - 1691 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-literal-arg/11") - 1692 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:break:" "F - test-convert-function-call-with-literal-arg/12") - 1693 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-literal-arg/13") - 1694 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-literal-arg/14") - 1695 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-literal-arg/15") - 1696 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-literal-arg/16") - 1697 (check-next-stream-line-equal _test-output-stream "do-add:" "F - test-convert-function-call-with-literal-arg/17") - 1698 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-literal-arg/18") - 1699 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-literal-arg/19") - 1700 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-literal-arg/20") - 1701 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-literal-arg/21") - 1702 (check-next-stream-line-equal _test-output-stream "$do-add:0x00000002:loop:" "F - test-convert-function-call-with-literal-arg/22") - 1703 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-literal-arg/23") - 1704 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-call-with-literal-arg/24") - 1705 (check-next-stream-line-equal _test-output-stream " 03/add *(ebp+0x0000000c) 0x00000000/r32" "F - test-convert-function-call-with-literal-arg/25") - 1706 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-call-with-literal-arg/26") - 1707 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-call-with-literal-arg/27") - 1708 (check-next-stream-line-equal _test-output-stream " e9/jump $do-add:0x00000002:break/disp32" "F - test-convert-function-call-with-literal-arg/28") - 1709 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-literal-arg/29") - 1710 (check-next-stream-line-equal _test-output-stream "$do-add:0x00000002:break:" "F - test-convert-function-call-with-literal-arg/30") - 1711 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-literal-arg/31") - 1712 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-literal-arg/32") - 1713 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-literal-arg/33") - 1714 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-literal-arg/34") + 1478 (flush _test-error-buffered-file) + 1479 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1485 # check output + 1486 (check-stream-equal _test-output-stream "" "F - test-return-with-wrong-type: output should be empty") + 1487 (check-next-stream-line-equal _test-error-stream "fn foo: return: 'x' has the wrong type" "F - test-return-with-wrong-type: error message") + 1488 # check that stop(1) was called + 1489 (check-ints-equal *(edx+4) 2 "F - test-return-with-wrong-type: exit status") + 1490 # don't restore from ebp + 1491 81 0/subop/add %esp 8/imm32 + 1492 # . epilogue + 1493 5d/pop-to-ebp + 1494 c3/return + 1495 + 1496 test-missing-return: + 1497 # . prologue + 1498 55/push-ebp + 1499 89/<- %ebp 4/r32/esp + 1500 # setup + 1501 (clear-stream _test-input-stream) + 1502 (clear-stream $_test-input-buffered-file->buffer) + 1503 (clear-stream _test-output-stream) + 1504 (clear-stream $_test-output-buffered-file->buffer) + 1505 (clear-stream _test-error-stream) + 1506 (clear-stream $_test-error-buffered-file->buffer) + 1507 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1508 68/push 0/imm32 + 1509 68/push 0/imm32 + 1510 89/<- %edx 4/r32/esp + 1511 (tailor-exit-descriptor %edx 0x10) + 1512 # + 1513 (write _test-input-stream "fn foo -> _/eax: int {\n") + 1514 (write _test-input-stream " var x/eax: boolean <- copy 0\n") + 1515 (write _test-input-stream "}\n") + 1516 # convert + 1517 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1518 # registers except esp clobbered at this point + 1519 # restore ed + 1520 89/<- %edx 4/r32/esp + 1521 (flush _test-output-buffered-file) + 1522 (flush _test-error-buffered-file) + 1523 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1529 # check output + 1530 (check-stream-equal _test-output-stream "" "F - test-missing-return: output should be empty") + 1531 (check-next-stream-line-equal _test-error-stream "fn foo: final statement should be a 'return'" "F - test-missing-return: error message") + 1532 # check that stop(1) was called + 1533 (check-ints-equal *(edx+4) 2 "F - test-missing-return: exit status") + 1534 # don't restore from ebp + 1535 81 0/subop/add %esp 8/imm32 + 1536 # . epilogue + 1537 5d/pop-to-ebp + 1538 c3/return + 1539 + 1540 test-early-exit-without-return: + 1541 # . prologue + 1542 55/push-ebp + 1543 89/<- %ebp 4/r32/esp + 1544 # setup + 1545 (clear-stream _test-input-stream) + 1546 (clear-stream $_test-input-buffered-file->buffer) + 1547 (clear-stream _test-output-stream) + 1548 (clear-stream $_test-output-buffered-file->buffer) + 1549 (clear-stream _test-error-stream) + 1550 (clear-stream $_test-error-buffered-file->buffer) + 1551 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1552 68/push 0/imm32 + 1553 68/push 0/imm32 + 1554 89/<- %edx 4/r32/esp + 1555 (tailor-exit-descriptor %edx 0x10) + 1556 # + 1557 (write _test-input-stream "fn foo -> _/eax: int {\n") + 1558 (write _test-input-stream " break\n") + 1559 (write _test-input-stream " return 0\n") + 1560 (write _test-input-stream "}\n") + 1561 # convert + 1562 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1563 # registers except esp clobbered at this point + 1564 # restore ed + 1565 89/<- %edx 4/r32/esp + 1566 (flush _test-output-buffered-file) + 1567 (flush _test-error-buffered-file) + 1568 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1574 # check output + 1575 (check-stream-equal _test-output-stream "" "F - test-early-exit-without-return: output should be empty") + 1576 (check-next-stream-line-equal _test-error-stream "fn foo has outputs, so you cannot 'break' out of the outermost block. Use 'return'." "F - test-early-exit-without-return: error message") + 1577 # check that stop(1) was called + 1578 (check-ints-equal *(edx+4) 2 "F - test-early-exit-without-return: exit status") + 1579 # don't restore from ebp + 1580 81 0/subop/add %esp 8/imm32 + 1581 # . epilogue + 1582 5d/pop-to-ebp + 1583 c3/return + 1584 + 1585 test-return-with-too-few-inouts: + 1586 # . prologue + 1587 55/push-ebp + 1588 89/<- %ebp 4/r32/esp + 1589 # setup + 1590 (clear-stream _test-input-stream) + 1591 (clear-stream $_test-input-buffered-file->buffer) + 1592 (clear-stream _test-output-stream) + 1593 (clear-stream $_test-output-buffered-file->buffer) + 1594 (clear-stream _test-error-stream) + 1595 (clear-stream $_test-error-buffered-file->buffer) + 1596 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1597 68/push 0/imm32 + 1598 68/push 0/imm32 + 1599 89/<- %edx 4/r32/esp + 1600 (tailor-exit-descriptor %edx 0x10) + 1601 # + 1602 (write _test-input-stream "fn foo -> _/eax: int {\n") + 1603 (write _test-input-stream " return\n") + 1604 (write _test-input-stream "}\n") + 1605 # convert + 1606 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1607 # registers except esp clobbered at this point + 1608 # restore ed + 1609 89/<- %edx 4/r32/esp + 1610 (flush _test-output-buffered-file) + 1611 (flush _test-error-buffered-file) + 1612 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1618 # check output + 1619 (check-stream-equal _test-output-stream "" "F - test-return-with-too-few-inouts: output should be empty") + 1620 (check-next-stream-line-equal _test-error-stream "fn foo: return: too few inouts" "F - test-return-with-too-few-inouts: error message") + 1621 # check that stop(1) was called + 1622 (check-ints-equal *(edx+4) 2 "F - test-return-with-too-few-inouts: exit status") + 1623 # don't restore from ebp + 1624 81 0/subop/add %esp 8/imm32 + 1625 # . epilogue + 1626 5d/pop-to-ebp + 1627 c3/return + 1628 + 1629 test-return-with-too-many-inouts: + 1630 # . prologue + 1631 55/push-ebp + 1632 89/<- %ebp 4/r32/esp + 1633 # setup + 1634 (clear-stream _test-input-stream) + 1635 (clear-stream $_test-input-buffered-file->buffer) + 1636 (clear-stream _test-output-stream) + 1637 (clear-stream $_test-output-buffered-file->buffer) + 1638 (clear-stream _test-error-stream) + 1639 (clear-stream $_test-error-buffered-file->buffer) + 1640 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1641 68/push 0/imm32 + 1642 68/push 0/imm32 + 1643 89/<- %edx 4/r32/esp + 1644 (tailor-exit-descriptor %edx 0x10) + 1645 # + 1646 (write _test-input-stream "fn foo -> _/eax: int {\n") + 1647 (write _test-input-stream " return 0, 0\n") + 1648 (write _test-input-stream "}\n") + 1649 # convert + 1650 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1651 # registers except esp clobbered at this point + 1652 # restore ed + 1653 89/<- %edx 4/r32/esp + 1654 (flush _test-output-buffered-file) + 1655 (flush _test-error-buffered-file) + 1656 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1662 # check output + 1663 (check-stream-equal _test-output-stream "" "F - test-return-with-too-many-inouts: output should be empty") + 1664 (check-next-stream-line-equal _test-error-stream "fn foo: return: too many inouts" "F - test-return-with-too-many-inouts: error message") + 1665 # check that stop(1) was called + 1666 (check-ints-equal *(edx+4) 2 "F - test-return-with-too-many-inouts: exit status") + 1667 # don't restore from ebp + 1668 81 0/subop/add %esp 8/imm32 + 1669 # . epilogue + 1670 5d/pop-to-ebp + 1671 c3/return + 1672 + 1673 test-return-unavailable-value: + 1674 # . prologue + 1675 55/push-ebp + 1676 89/<- %ebp 4/r32/esp + 1677 # setup + 1678 (clear-stream _test-input-stream) + 1679 (clear-stream $_test-input-buffered-file->buffer) + 1680 (clear-stream _test-output-stream) + 1681 (clear-stream $_test-output-buffered-file->buffer) + 1682 (clear-stream _test-error-stream) + 1683 (clear-stream $_test-error-buffered-file->buffer) + 1684 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1685 68/push 0/imm32 + 1686 68/push 0/imm32 + 1687 89/<- %edx 4/r32/esp + 1688 (tailor-exit-descriptor %edx 0x10) + 1689 # + 1690 (write _test-input-stream "fn foo -> _/eax: int, _/ecx: int {\n") + 1691 (write _test-input-stream " var x/eax: int <- copy 0\n") + 1692 (write _test-input-stream " var y/ecx: int <- copy 0\n") + 1693 (write _test-input-stream " return y, x\n") + 1694 (write _test-input-stream "}\n") + 1695 # convert + 1696 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1697 # registers except esp clobbered at this point + 1698 # restore ed + 1699 89/<- %edx 4/r32/esp + 1700 (flush _test-output-buffered-file) + 1701 (flush _test-error-buffered-file) + 1702 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1708 # check output + 1709 (check-stream-equal _test-output-stream "" "F - test-return-unavailable-value: output should be empty") + 1710 (check-next-stream-line-equal _test-error-stream "fn foo: return: 'x' is no longer available" "F - test-return-unavailable-value: error message") + 1711 # check that stop(1) was called + 1712 (check-ints-equal *(edx+4) 2 "F - test-return-unavailable-value: exit status") + 1713 # don't restore from ebp + 1714 81 0/subop/add %esp 8/imm32 1715 # . epilogue - 1716 89/<- %esp 5/r32/ebp - 1717 5d/pop-to-ebp - 1718 c3/return - 1719 - 1720 test-convert-function-call-with-literal-string-arg: - 1721 # . prologue - 1722 55/push-ebp - 1723 89/<- %ebp 4/r32/esp - 1724 # setup - 1725 (clear-stream _test-input-stream) - 1726 (clear-stream $_test-input-buffered-file->buffer) - 1727 (clear-stream _test-output-stream) - 1728 (clear-stream $_test-output-buffered-file->buffer) - 1729 # - 1730 (write _test-input-stream "fn foo {\n") - 1731 (write _test-input-stream " string-func \"abc\"\n") + 1716 5d/pop-to-ebp + 1717 c3/return + 1718 + 1719 test-convert-return-with-duplicate-values: + 1720 # . prologue + 1721 55/push-ebp + 1722 89/<- %ebp 4/r32/esp + 1723 # setup + 1724 (clear-stream _test-input-stream) + 1725 (clear-stream $_test-input-buffered-file->buffer) + 1726 (clear-stream _test-output-stream) + 1727 (clear-stream $_test-output-buffered-file->buffer) + 1728 # + 1729 (write _test-input-stream "fn foo -> _/eax: int, _/ecx: int {\n") + 1730 (write _test-input-stream " var x/eax: int <- copy 0x34\n") + 1731 (write _test-input-stream " return x, x\n") 1732 (write _test-input-stream "}\n") - 1733 (write _test-input-stream "sig string-func in: (addr array byte)\n") - 1734 # convert - 1735 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 1736 # no errors - 1737 # not bothering checking output - 1738 # . epilogue - 1739 89/<- %esp 5/r32/ebp - 1740 5d/pop-to-ebp - 1741 c3/return - 1742 - 1743 test-convert-function-call-with-null-addr: - 1744 # . prologue - 1745 55/push-ebp - 1746 89/<- %ebp 4/r32/esp - 1747 # setup - 1748 (clear-stream _test-input-stream) - 1749 (clear-stream $_test-input-buffered-file->buffer) - 1750 (clear-stream _test-output-stream) - 1751 (clear-stream $_test-output-buffered-file->buffer) - 1752 # - 1753 (write _test-input-stream "fn foo {\n") - 1754 (write _test-input-stream " bar 0\n") - 1755 (write _test-input-stream "}\n") - 1756 (write _test-input-stream "sig bar in: (addr int)\n") - 1757 # convert - 1758 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 1759 # no errors - 1760 # not bothering checking output + 1733 # convert + 1734 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1735 (flush _test-output-buffered-file) + 1736 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1742 # check output + 1743 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-return-with-duplicate-values/0") + 1744 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-return-with-duplicate-values/1") + 1745 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-return-with-duplicate-values/2") + 1746 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-return-with-duplicate-values/3") + 1747 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-return-with-duplicate-values/4") + 1748 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-return-with-duplicate-values/5") + 1749 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-return-with-duplicate-values/6") + 1750 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0x34/imm32" "F - test-convert-return-with-duplicate-values/7") + 1751 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-return-with-duplicate-values/8") + 1752 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000001/r32" "F - test-convert-return-with-duplicate-values/9") + 1753 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-return-with-duplicate-values/10") + 1754 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-return-with-duplicate-values/11") + 1755 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-return-with-duplicate-values/12") + 1756 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-return-with-duplicate-values/13") + 1757 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-return-with-duplicate-values/14") + 1758 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-return-with-duplicate-values/15") + 1759 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-return-with-duplicate-values/16") + 1760 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-return-with-duplicate-values/17") 1761 # . epilogue 1762 89/<- %esp 5/r32/ebp 1763 5d/pop-to-ebp 1764 c3/return 1765 - 1766 test-convert-function-call-with-signature: + 1766 test-convert-return-with-duplicate-values-2: 1767 # . prologue 1768 55/push-ebp 1769 89/<- %ebp 4/r32/esp @@ -1705,39 +1700,39 @@ if ('onhashchange' in window) { 1773 (clear-stream _test-output-stream) 1774 (clear-stream $_test-output-buffered-file->buffer) 1775 # - 1776 (write _test-input-stream "fn main -> _/ebx: int {\n") - 1777 (write _test-input-stream " var result/eax: int <- do-add 3 4\n") - 1778 (write _test-input-stream " return result\n") + 1776 (write _test-input-stream "fn foo -> _/eax: int, _/ecx: int {\n") + 1777 (write _test-input-stream " var x/ecx: int <- copy 0x34\n") + 1778 (write _test-input-stream " return x, x\n") 1779 (write _test-input-stream "}\n") - 1780 (write _test-input-stream "sig do-add a: int, b: int -> _/eax: int\n") - 1781 # convert - 1782 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 1783 (flush _test-output-buffered-file) - 1784 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1790 # check output - 1791 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call-with-signature/0") - 1792 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-signature/1") - 1793 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-signature/2") - 1794 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-signature/3") - 1795 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-signature/4") - 1796 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:loop:" "F - test-convert-function-call-with-signature/5") - 1797 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-literal-arg/6") - 1798 (check-next-stream-line-equal _test-output-stream " (do-add 3 4)" "F - test-convert-function-call-with-signature/6") - 1799 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8") - 1800 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-local-var-in-reg/9") - 1801 (check-next-stream-line-equal _test-output-stream " e9/jump $main:0x00000001:break/disp32" "F - test-convert-function-call-with-literal-arg/10") - 1802 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-signature/7") - 1803 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:break:" "F - test-convert-function-call-with-signature/8") - 1804 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-signature/9") - 1805 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-signature/10") - 1806 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-signature/11") - 1807 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-signature/12") + 1780 # convert + 1781 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 1782 (flush _test-output-buffered-file) + 1783 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1789 # check output + 1790 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-return-with-duplicate-values-2/0") + 1791 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-return-with-duplicate-values-2/1") + 1792 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-return-with-duplicate-values-2/2") + 1793 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-return-with-duplicate-values-2/3") + 1794 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-return-with-duplicate-values-2/4") + 1795 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-return-with-duplicate-values-2/5") + 1796 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-return-with-duplicate-values-2/6") + 1797 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x34/imm32" "F - test-convert-return-with-duplicate-values-2/7") + 1798 (check-next-stream-line-equal _test-output-stream " 8b/-> %ecx 0x00000000/r32" "F - test-convert-return-with-duplicate-values-2/8") + 1799 (check-next-stream-line-equal _test-output-stream " 8b/-> %ecx 0x00000001/r32" "F - test-convert-return-with-duplicate-values-2/9") + 1800 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-return-with-duplicate-values-2/10") + 1801 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-return-with-duplicate-values-2/11") + 1802 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-return-with-duplicate-values-2/12") + 1803 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-return-with-duplicate-values-2/13") + 1804 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-return-with-duplicate-values-2/14") + 1805 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-return-with-duplicate-values-2/15") + 1806 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-return-with-duplicate-values-2/16") + 1807 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-return-with-duplicate-values-2/17") 1808 # . epilogue 1809 89/<- %esp 5/r32/ebp 1810 5d/pop-to-ebp 1811 c3/return 1812 - 1813 test-convert-function-with-local-var-in-mem: + 1813 test-stmt-with-unknown-var: 1814 # . prologue 1815 55/push-ebp 1816 89/<- %ebp 4/r32/esp @@ -1746,37 +1741,37 @@ if ('onhashchange' in window) { 1819 (clear-stream $_test-input-buffered-file->buffer) 1820 (clear-stream _test-output-stream) 1821 (clear-stream $_test-output-buffered-file->buffer) - 1822 # - 1823 (write _test-input-stream "fn foo {\n") - 1824 (write _test-input-stream " var x: int\n") - 1825 (write _test-input-stream " increment x\n") - 1826 (write _test-input-stream "}\n") - 1827 # convert - 1828 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 1829 (flush _test-output-buffered-file) - 1830 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1836 # check output - 1837 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-mem/0") - 1838 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-mem/1") - 1839 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-mem/2") - 1840 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-mem/3") - 1841 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-mem/4") - 1842 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-mem/5") - 1843 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-mem/6") - 1844 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-mem/7") - 1845 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-mem/8") - 1846 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-mem/9") - 1847 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-mem/10") - 1848 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-mem/11") - 1849 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-mem/12") - 1850 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-mem/13") - 1851 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-mem/14") - 1852 # . epilogue - 1853 89/<- %esp 5/r32/ebp + 1822 (clear-stream _test-error-stream) + 1823 (clear-stream $_test-error-buffered-file->buffer) + 1824 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 1825 68/push 0/imm32 + 1826 68/push 0/imm32 + 1827 89/<- %edx 4/r32/esp + 1828 (tailor-exit-descriptor %edx 0x10) + 1829 # + 1830 (write _test-input-stream "fn foo {\n") + 1831 (write _test-input-stream " x <- copy 0x34\n") + 1832 (write _test-input-stream "}\n") + 1833 # convert + 1834 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1835 # registers except esp clobbered at this point + 1836 # restore ed + 1837 89/<- %edx 4/r32/esp + 1838 (flush _test-output-buffered-file) + 1839 (flush _test-error-buffered-file) + 1840 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1846 # check output + 1847 (check-stream-equal _test-output-stream "" "F - test-stmt-with-unknown-var: output should be empty") + 1848 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-stmt-with-unknown-var: error message") + 1849 # check that stop(1) was called + 1850 (check-ints-equal *(edx+4) 2 "F - test-stmt-with-unknown-var: exit status") + 1851 # don't restore from ebp + 1852 81 0/subop/add %esp 8/imm32 + 1853 # . epilogue 1854 5d/pop-to-ebp 1855 c3/return 1856 - 1857 test-convert-invalid-literal: + 1857 test-stmt-with-invalid-identifier: 1858 # . prologue 1859 55/push-ebp 1860 89/<- %ebp 4/r32/esp @@ -1794,28 +1789,28 @@ if ('onhashchange' in window) { 1872 (tailor-exit-descriptor %edx 0x10) 1873 # 1874 (write _test-input-stream "fn foo {\n") - 1875 (write _test-input-stream " increment 1n\n") + 1875 (write _test-input-stream " 1 <- copy 0x34\n") 1876 (write _test-input-stream "}\n") 1877 # convert - 1878 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1878 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) 1879 # registers except esp clobbered at this point 1880 # restore ed 1881 89/<- %edx 4/r32/esp 1882 (flush _test-output-buffered-file) - 1883 (flush _test-error-buffered-file) + 1883 (flush _test-error-buffered-file) 1884 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1890 # check output - 1891 (check-stream-equal _test-output-stream "" "F - test-convert-invalid-literal: output should be empty") - 1892 (check-next-stream-line-equal _test-error-stream "fn foo: variable '1n' cannot begin with a digit (or do you have a typo in a number?)" "F - test-convert-invalid-literal: error message") + 1891 (check-stream-equal _test-output-stream "" "F - test-stmt-with-invalid-identifier: output should be empty") + 1892 (check-next-stream-line-equal _test-error-stream "fn foo: invalid identifier '1'" "F - test-stmt-with-invalid-identifier: error message") 1893 # check that stop(1) was called - 1894 (check-ints-equal *(edx+4) 2 "F - test-convert-invalid-literal: exit status") + 1894 (check-ints-equal *(edx+4) 2 "F - test-stmt-with-invalid-identifier: exit status") 1895 # don't restore from ebp 1896 81 0/subop/add %esp 8/imm32 1897 # . epilogue 1898 5d/pop-to-ebp 1899 c3/return 1900 - 1901 test-local-var-in-mem-has-no-initializer: + 1901 test-stmt-with-deref-var: 1902 # . prologue 1903 55/push-ebp 1904 89/<- %ebp 4/r32/esp @@ -1833,1724 +1828,1724 @@ if ('onhashchange' in window) { 1916 (tailor-exit-descriptor %edx 0x10) 1917 # 1918 (write _test-input-stream "fn foo {\n") - 1919 (write _test-input-stream " var x: int <- copy 0\n") - 1920 (write _test-input-stream " increment x\n") - 1921 (write _test-input-stream "}\n") - 1922 # convert - 1923 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 1924 # registers except esp clobbered at this point - 1925 # restore ed - 1926 89/<- %edx 4/r32/esp - 1927 (flush _test-output-buffered-file) - 1928 (flush _test-error-buffered-file) - 1929 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 1935 # check output - 1936 (check-stream-equal _test-output-stream "" "F - test-var-in-mem-has-no-initializer: output should be empty") - 1937 (check-next-stream-line-equal _test-error-stream "fn foo: var x: variables on the stack can't take an initializer" "F - test-var-in-mem-has-no-initializer: error message") - 1938 # check that stop(1) was called - 1939 (check-ints-equal *(edx+4) 2 "F - test-var-in-mem-has-no-initializer: exit status") - 1940 # don't restore from ebp - 1941 81 0/subop/add %esp 8/imm32 - 1942 # . epilogue - 1943 5d/pop-to-ebp - 1944 c3/return - 1945 - 1946 test-convert-function-with-local-var-with-compound-type-in-mem: - 1947 # . prologue - 1948 55/push-ebp - 1949 89/<- %ebp 4/r32/esp - 1950 # setup - 1951 (clear-stream _test-input-stream) - 1952 (clear-stream $_test-input-buffered-file->buffer) - 1953 (clear-stream _test-output-stream) - 1954 (clear-stream $_test-output-buffered-file->buffer) - 1955 # - 1956 (write _test-input-stream "fn foo {\n") - 1957 (write _test-input-stream " var x: (addr int)\n") - 1958 (write _test-input-stream " copy-to x, 0\n") + 1919 (write _test-input-stream " *x <- copy 0x34\n") + 1920 (write _test-input-stream "}\n") + 1921 # convert + 1922 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 1923 # registers except esp clobbered at this point + 1924 # restore ed + 1925 89/<- %edx 4/r32/esp + 1926 (flush _test-output-buffered-file) + 1927 (flush _test-error-buffered-file) + 1928 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 1934 # check output + 1935 (check-stream-equal _test-output-stream "" "F - test-stmt-with-deref-var: output should be empty") + 1936 (check-next-stream-line-equal _test-error-stream "fn foo: output '*x' should write to a register, and therefore cannot be dereferenced" "F - test-stmt-with-deref-var: error message") + 1937 # check that stop(1) was called + 1938 (check-ints-equal *(edx+4) 2 "F - test-stmt-with-deref-var: exit status") + 1939 # don't restore from ebp + 1940 81 0/subop/add %esp 8/imm32 + 1941 # . epilogue + 1942 5d/pop-to-ebp + 1943 c3/return + 1944 + 1945 test-convert-function-with-literal-arg: + 1946 # . prologue + 1947 55/push-ebp + 1948 89/<- %ebp 4/r32/esp + 1949 # setup + 1950 (clear-stream _test-input-stream) + 1951 (clear-stream $_test-input-buffered-file->buffer) + 1952 (clear-stream _test-output-stream) + 1953 (clear-stream $_test-output-buffered-file->buffer) + 1954 # + 1955 (write _test-input-stream "fn foo a: int, b: int -> _/eax: int {\n") + 1956 (write _test-input-stream " var result/eax: int <- copy a\n") + 1957 (write _test-input-stream " result <- add 1\n") + 1958 (write _test-input-stream " return result\n") 1959 (write _test-input-stream "}\n") 1960 # convert 1961 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 1962 (flush _test-output-buffered-file) 1963 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 1969 # check output - 1970 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/0") - 1971 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-compound-type-in-mem/1") - 1972 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/2") - 1973 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/3") - 1974 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-compound-type-in-mem/4") - 1975 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/5") - 1976 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-compound-type-in-mem/6") - 1977 (check-next-stream-line-equal _test-output-stream " c7 0/subop/copy *(ebp+0xfffffffc) 0/imm32" "F - test-convert-function-with-local-var-with-compound-type-in-mem/7") - 1978 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-with-compound-type-in-mem/8") - 1979 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-compound-type-in-mem/9") - 1980 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/10") - 1981 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-compound-type-in-mem/11") - 1982 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/12") - 1983 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/13") - 1984 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-compound-type-in-mem/14") - 1985 # . epilogue - 1986 89/<- %esp 5/r32/ebp - 1987 5d/pop-to-ebp - 1988 c3/return - 1989 - 1990 test-convert-function-with-local-var-in-reg: - 1991 # . prologue - 1992 55/push-ebp - 1993 89/<- %ebp 4/r32/esp - 1994 # setup - 1995 (clear-stream _test-input-stream) - 1996 (clear-stream $_test-input-buffered-file->buffer) - 1997 (clear-stream _test-output-stream) - 1998 (clear-stream $_test-output-buffered-file->buffer) - 1999 # - 2000 (write _test-input-stream "fn foo {\n") - 2001 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 2002 (write _test-input-stream " x <- increment\n") - 2003 (write _test-input-stream "}\n") - 2004 # convert - 2005 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2006 (flush _test-output-buffered-file) - 2007 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2013 # check output - 2014 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-reg/0") - 2015 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-reg/1") - 2016 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-reg/2") - 2017 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-reg/3") - 2018 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-reg/4") - 2019 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-reg/5") - 2020 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-local-var-in-reg/6") - 2021 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-function-with-local-var-in-reg/7") - 2022 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-convert-function-with-local-var-in-reg/8") - 2023 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-local-var-in-reg/9") - 2024 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-reg/10") - 2025 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-reg/11") - 2026 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-reg/12") - 2027 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-reg/13") - 2028 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-reg/14") - 2029 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-reg/15") - 2030 # . epilogue - 2031 89/<- %esp 5/r32/ebp - 2032 5d/pop-to-ebp - 2033 c3/return - 2034 - 2035 test-convert-function-with-allocate: - 2036 # . prologue - 2037 55/push-ebp - 2038 89/<- %ebp 4/r32/esp - 2039 # setup - 2040 (clear-stream _test-input-stream) - 2041 (clear-stream $_test-input-buffered-file->buffer) - 2042 (clear-stream _test-output-stream) - 2043 (clear-stream $_test-output-buffered-file->buffer) - 2044 # - 2045 (write _test-input-stream "fn foo {\n") - 2046 (write _test-input-stream " var x/ecx: (addr handle int) <- copy 0\n") - 2047 (write _test-input-stream " allocate x\n") - 2048 (write _test-input-stream "}\n") - 2049 # convert - 2050 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2051 (flush _test-output-buffered-file) - 2052 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2058 # check output - 2059 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-allocate/0") - 2060 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-allocate/1") - 2061 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-allocate/2") - 2062 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-allocate/3") - 2063 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-allocate/4") - 2064 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-allocate/5") - 2065 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-allocate/6") - 2066 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-allocate/7") - 2067 (check-next-stream-line-equal _test-output-stream " (allocate Heap 0x00000004 %ecx)" "F - test-convert-function-with-allocate/8") # 4 = size-of(int) - 2068 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-allocate/9") - 2069 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-allocate/10") - 2070 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-allocate/11") - 2071 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-allocate/12") - 2072 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-allocate/13") - 2073 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-allocate/14") - 2074 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-allocate/15") - 2075 # . epilogue - 2076 89/<- %esp 5/r32/ebp - 2077 5d/pop-to-ebp - 2078 c3/return - 2079 - 2080 test-initializer-in-hex: - 2081 # . prologue - 2082 55/push-ebp - 2083 89/<- %ebp 4/r32/esp - 2084 # setup - 2085 (clear-stream _test-input-stream) - 2086 (clear-stream $_test-input-buffered-file->buffer) - 2087 (clear-stream _test-output-stream) - 2088 (clear-stream $_test-output-buffered-file->buffer) - 2089 (clear-stream _test-error-stream) - 2090 (clear-stream $_test-error-buffered-file->buffer) - 2091 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2092 68/push 0/imm32 - 2093 68/push 0/imm32 - 2094 89/<- %edx 4/r32/esp - 2095 (tailor-exit-descriptor %edx 0x10) - 2096 # - 2097 (write _test-input-stream "fn foo {\n") - 2098 (write _test-input-stream " var x/ecx: int <- copy 10\n") - 2099 (write _test-input-stream "}\n") - 2100 # convert - 2101 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2102 # registers except esp clobbered at this point - 2103 # restore ed - 2104 89/<- %edx 4/r32/esp - 2105 (flush _test-output-buffered-file) - 2106 (flush _test-error-buffered-file) - 2107 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2113 # check output - 2114 (check-stream-equal _test-output-stream "" "F - test-initializer-in-hex: output should be empty") - 2115 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; start '10' with a '0x' to be unambiguous, converting it to hexadecimal as necessary." "F - test-initializer-in-hex: error message") - 2116 # check that stop(1) was called - 2117 (check-ints-equal *(edx+4) 2 "F - test-initializer-in-hex: exit status") - 2118 # don't restore from ebp - 2119 81 0/subop/add %esp 8/imm32 - 2120 # . epilogue - 2121 5d/pop-to-ebp - 2122 c3/return - 2123 - 2124 test-convert-function-with-second-local-var-in-same-reg: - 2125 # . prologue - 2126 55/push-ebp - 2127 89/<- %ebp 4/r32/esp - 2128 # setup - 2129 (clear-stream _test-input-stream) - 2130 (clear-stream $_test-input-buffered-file->buffer) - 2131 (clear-stream _test-output-stream) - 2132 (clear-stream $_test-output-buffered-file->buffer) - 2133 # - 2134 (write _test-input-stream "fn foo {\n") - 2135 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 2136 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 2137 (write _test-input-stream " y <- increment\n") - 2138 (write _test-input-stream "}\n") - 2139 # convert - 2140 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2141 (flush _test-output-buffered-file) - 2142 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2148 # check output - 2149 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-second-local-var-in-same-reg/0") - 2150 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-second-local-var-in-same-reg/1") - 2151 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-second-local-var-in-same-reg/2") - 2152 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-second-local-var-in-same-reg/3") - 2153 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-second-local-var-in-same-reg/4") - 2154 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-second-local-var-in-same-reg/5") - 2155 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-second-local-var-in-same-reg/6") - 2156 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-function-with-second-local-var-in-same-reg/7") - 2157 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-convert-function-with-second-local-var-in-same-reg/8") - 2158 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-convert-function-with-second-local-var-in-same-reg/9") - 2159 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-second-local-var-in-same-reg/10") - 2160 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-second-local-var-in-same-reg/11") - 2161 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-second-local-var-in-same-reg/12") - 2162 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-second-local-var-in-same-reg/13") - 2163 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-second-local-var-in-same-reg/14") - 2164 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-second-local-var-in-same-reg/15") - 2165 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-second-local-var-in-same-reg/16") - 2166 # . epilogue - 2167 89/<- %esp 5/r32/ebp - 2168 5d/pop-to-ebp - 2169 c3/return - 2170 - 2171 test-read-clobbered-reg-var: - 2172 # . prologue - 2173 55/push-ebp - 2174 89/<- %ebp 4/r32/esp - 2175 # setup - 2176 (clear-stream _test-input-stream) - 2177 (clear-stream $_test-input-buffered-file->buffer) - 2178 (clear-stream _test-output-stream) - 2179 (clear-stream $_test-output-buffered-file->buffer) - 2180 (clear-stream _test-error-stream) - 2181 (clear-stream $_test-error-buffered-file->buffer) - 2182 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) # bytes of args in call to convert-mu - 2183 68/push 0/imm32 - 2184 68/push 0/imm32 - 2185 89/<- %edx 4/r32/esp - 2186 (tailor-exit-descriptor %edx 0x10) - 2187 # - 2188 (write _test-input-stream "fn foo {\n") - 2189 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 2190 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 2191 (write _test-input-stream " x <- increment\n") - 2192 (write _test-input-stream "}\n") - 2193 # convert - 2194 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2195 # registers except esp clobbered at this point - 2196 # restore ed - 2197 89/<- %edx 4/r32/esp - 2198 (flush _test-output-buffered-file) - 2199 (flush _test-error-buffered-file) - 2200 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2206 # check output - 2207 (check-stream-equal _test-output-stream "" "F - test-read-clobbered-reg-var: output should be empty") - 2208 (check-next-stream-line-equal _test-error-stream "fn foo: register ecx reads var 'x' after writing var 'y'" "F - test-read-clobbered-reg-var: error message") - 2209 # check that stop(1) was called - 2210 (check-ints-equal *(edx+4) 2 "F - test-read-clobbered-reg-var: exit status") - 2211 # don't restore from ebp - 2212 81 0/subop/add %esp 8/imm32 - 2213 # . epilogue - 2214 5d/pop-to-ebp - 2215 c3/return - 2216 - 2217 test-overlapping-int-fp-registers: - 2218 # . prologue - 2219 55/push-ebp - 2220 89/<- %ebp 4/r32/esp - 2221 # setup - 2222 (clear-stream _test-input-stream) - 2223 (clear-stream $_test-input-buffered-file->buffer) - 2224 (clear-stream _test-output-stream) - 2225 (clear-stream $_test-output-buffered-file->buffer) - 2226 (clear-stream _test-error-stream) - 2227 (clear-stream $_test-error-buffered-file->buffer) - 2228 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) # bytes of args in call to convert-mu - 2229 68/push 0/imm32 - 2230 68/push 0/imm32 - 2231 89/<- %edx 4/r32/esp - 2232 (tailor-exit-descriptor %edx 0x10) - 2233 # - 2234 (write _test-input-stream "fn foo {\n") - 2235 (write _test-input-stream " var x/eax: int <- copy 3\n") - 2236 (write _test-input-stream " var y/xmm0: float <- convert x\n") - 2237 (write _test-input-stream " x <- increment\n") - 2238 (write _test-input-stream "}\n") - 2239 # convert - 2240 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2241 # registers except esp clobbered at this point - 2242 # restore ed - 2243 89/<- %edx 4/r32/esp - 2244 (flush _test-output-buffered-file) - 2245 (flush _test-error-buffered-file) - 2246 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2252 # no errors - 2253 (check-next-stream-line-equal _test-error-stream "" "F - test-overlapping-int-fp-registers: error message") - 2254 # don't bother checking the generated code - 2255 # don't restore from ebp - 2256 81 0/subop/add %esp 8/imm32 - 2257 # . epilogue - 2258 5d/pop-to-ebp - 2259 c3/return - 2260 - 2261 test-convert-function-call: - 2262 # . prologue - 2263 55/push-ebp - 2264 89/<- %ebp 4/r32/esp - 2265 # setup - 2266 (clear-stream _test-input-stream) - 2267 (clear-stream $_test-input-buffered-file->buffer) - 2268 (clear-stream _test-output-stream) - 2269 (clear-stream $_test-output-buffered-file->buffer) - 2270 # - 2271 (write _test-input-stream "fn main -> _/ebx: int {\n") - 2272 (write _test-input-stream " var result/ebx: int <- foo\n") - 2273 (write _test-input-stream " return result\n") - 2274 (write _test-input-stream "}\n") - 2275 (write _test-input-stream "fn foo -> _/ebx: int {\n") - 2276 (write _test-input-stream " var result/ebx: int <- copy 3\n") - 2277 (write _test-input-stream " return result\n") - 2278 (write _test-input-stream "}\n") - 2279 # convert - 2280 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2281 (flush _test-output-buffered-file) - 2282 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2288 # check output - 2289 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call/0") - 2290 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call/1") - 2291 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call/2") - 2292 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call/3") - 2293 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call/4") - 2294 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:loop:" "F - test-convert-function-call/5") - 2295 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-function-call-with-literal-arg/6") - 2296 (check-next-stream-line-equal _test-output-stream " (foo)" "F - test-convert-function-call/6") - 2297 (check-next-stream-line-equal _test-output-stream " 8b/-> %ebx 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8") - 2298 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-call-with-literal-arg/27") - 2299 (check-next-stream-line-equal _test-output-stream " e9/jump $main:0x00000001:break/disp32" "F - test-convert-function-call-with-literal-arg/10") - 2300 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call/7") - 2301 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:break:" "F - test-convert-function-call/8") - 2302 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call/9") - 2303 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call/10") - 2304 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call/11") - 2305 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call/12") - 2306 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call/13") - 2307 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call/14") - 2308 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call/15") - 2309 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call/16") - 2310 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call/17") - 2311 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-call/18") - 2312 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-function-call-with-literal-arg/6") - 2313 (check-next-stream-line-equal _test-output-stream " bb/copy-to-ebx 3/imm32" "F - test-convert-function-call/19") - 2314 (check-next-stream-line-equal _test-output-stream " 8b/-> %ebx 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8") - 2315 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-call-with-literal-arg/27") - 2316 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-call-with-literal-arg/10") - 2317 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call/20") - 2318 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-call/21") - 2319 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call/22") - 2320 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call/23") - 2321 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call/24") - 2322 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call/25") - 2323 # . epilogue - 2324 89/<- %esp 5/r32/ebp - 2325 5d/pop-to-ebp - 2326 c3/return - 2327 - 2328 test-convert-function-call-with-inout-with-compound-type: - 2329 # . prologue - 2330 55/push-ebp - 2331 89/<- %ebp 4/r32/esp - 2332 # setup - 2333 (clear-stream _test-input-stream) - 2334 (clear-stream $_test-input-buffered-file->buffer) - 2335 (clear-stream _test-output-stream) - 2336 (clear-stream $_test-output-buffered-file->buffer) - 2337 # - 2338 (write _test-input-stream "fn f {\n") - 2339 (write _test-input-stream " var x: (addr int)\n") - 2340 (write _test-input-stream " g x\n") - 2341 (write _test-input-stream "}\n") - 2342 (write _test-input-stream "fn g a: (addr int) {\n") - 2343 (write _test-input-stream "}\n") - 2344 # convert - 2345 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2346 (flush _test-output-buffered-file) - 2347 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2353 # check output - 2354 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-inout-with-compound-type/0") - 2355 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-inout-with-compound-type/1") - 2356 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-inout-with-compound-type/2") - 2357 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-inout-with-compound-type/3") - 2358 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-inout-with-compound-type/4") - 2359 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-inout-with-compound-type/5") - 2360 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-inout-with-compound-type/6") - 2361 (check-next-stream-line-equal _test-output-stream " (g *(ebp+0xfffffffc))" "F - test-convert-function-call-with-inout-with-compound-type/7") - 2362 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-call-with-inout-with-compound-type/8") - 2363 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-inout-with-compound-type/9") - 2364 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-inout-with-compound-type/10") - 2365 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-inout-with-compound-type/11") - 2366 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-inout-with-compound-type/12") - 2367 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-inout-with-compound-type/13") - 2368 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-inout-with-compound-type/14") - 2369 (check-next-stream-line-equal _test-output-stream "g:" "F - test-convert-function-call-with-inout-with-compound-type/15") - 2370 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-inout-with-compound-type/16") - 2371 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-inout-with-compound-type/17") - 2372 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-inout-with-compound-type/18") - 2373 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-inout-with-compound-type/19") - 2374 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-inout-with-compound-type/20") - 2375 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-inout-with-compound-type/21") - 2376 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-inout-with-compound-type/22") - 2377 # . epilogue - 2378 89/<- %esp 5/r32/ebp - 2379 5d/pop-to-ebp - 2380 c3/return - 2381 - 2382 test-convert-function-call-with-inout-with-type-parameter: - 2383 # . prologue - 2384 55/push-ebp - 2385 89/<- %ebp 4/r32/esp - 2386 # setup - 2387 (clear-stream _test-input-stream) - 2388 (clear-stream $_test-input-buffered-file->buffer) - 2389 (clear-stream _test-output-stream) - 2390 (clear-stream $_test-output-buffered-file->buffer) - 2391 (clear-stream _test-error-stream) - 2392 (clear-stream $_test-error-buffered-file->buffer) - 2393 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2394 68/push 0/imm32 - 2395 68/push 0/imm32 - 2396 89/<- %edx 4/r32/esp - 2397 (tailor-exit-descriptor %edx 0x10) - 2398 # - 2399 (write _test-input-stream "fn f {\n") - 2400 (write _test-input-stream " var x: (addr int)\n") - 2401 (write _test-input-stream " g x\n") - 2402 (write _test-input-stream "}\n") - 2403 (write _test-input-stream "fn g a: (addr _) {\n") - 2404 (write _test-input-stream "}\n") - 2405 # convert - 2406 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2407 # registers except esp clobbered at this point - 2408 # restore ed - 2409 89/<- %edx 4/r32/esp - 2410 (flush _test-output-buffered-file) - 2411 (flush _test-error-buffered-file) - 2412 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2418 # no error; types matched - 2419 (check-stream-equal _test-error-stream "" "F - test-convert-function-call-with-inout-with-type-parameter: error stream should be empty") - 2420 # don't bother checking the generated code; that's in the test 'test-local-clobbered-by-fn-output' below - 2421 # don't restore from ebp - 2422 81 0/subop/add %esp 8/imm32 - 2423 # . epilogue - 2424 5d/pop-to-ebp - 2425 c3/return - 2426 - 2427 test-convert-function-call-with-incorrect-inout-type: - 2428 # . prologue - 2429 55/push-ebp - 2430 89/<- %ebp 4/r32/esp - 2431 # setup - 2432 (clear-stream _test-input-stream) - 2433 (clear-stream $_test-input-buffered-file->buffer) - 2434 (clear-stream _test-output-stream) - 2435 (clear-stream $_test-output-buffered-file->buffer) - 2436 (clear-stream _test-error-stream) - 2437 (clear-stream $_test-error-buffered-file->buffer) - 2438 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2439 68/push 0/imm32 - 2440 68/push 0/imm32 - 2441 89/<- %edx 4/r32/esp - 2442 (tailor-exit-descriptor %edx 0x10) - 2443 # - 2444 (write _test-input-stream "fn f {\n") - 2445 (write _test-input-stream " var x: int\n") - 2446 (write _test-input-stream " g x\n") - 2447 (write _test-input-stream "}\n") - 2448 (write _test-input-stream "fn g a: foo {\n") - 2449 (write _test-input-stream "}\n") - 2450 # convert - 2451 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2452 # registers except esp clobbered at this point - 2453 # restore ed - 2454 89/<- %edx 4/r32/esp - 2455 (flush _test-output-buffered-file) - 2456 (flush _test-error-buffered-file) - 2457 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2463 # check output - 2464 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-inout-type: output should be empty") - 2465 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'x' is not right" "F - test-convert-function-call-with-incorrect-inout-type: error message") - 2466 # check that stop(1) was called - 2467 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-inout-type: exit status") - 2468 # don't restore from ebp - 2469 81 0/subop/add %esp 8/imm32 - 2470 5d/pop-to-ebp - 2471 c3/return - 2472 - 2473 test-convert-function-call-with-inout-with-incorrect-compound-type: - 2474 # . prologue - 2475 55/push-ebp - 2476 89/<- %ebp 4/r32/esp - 2477 # setup - 2478 (clear-stream _test-input-stream) - 2479 (clear-stream $_test-input-buffered-file->buffer) - 2480 (clear-stream _test-output-stream) - 2481 (clear-stream $_test-output-buffered-file->buffer) - 2482 (clear-stream _test-error-stream) - 2483 (clear-stream $_test-error-buffered-file->buffer) - 2484 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2485 68/push 0/imm32 - 2486 68/push 0/imm32 - 2487 89/<- %edx 4/r32/esp - 2488 (tailor-exit-descriptor %edx 0x10) - 2489 # - 2490 (write _test-input-stream "fn f {\n") - 2491 (write _test-input-stream " var x: (addr int)\n") - 2492 (write _test-input-stream " g x\n") - 2493 (write _test-input-stream "}\n") - 2494 (write _test-input-stream "fn g a: (addr bool) {\n") - 2495 (write _test-input-stream "}\n") - 2496 # convert - 2497 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2498 # registers except esp clobbered at this point - 2499 # restore ed - 2500 89/<- %edx 4/r32/esp - 2501 (flush _test-output-buffered-file) - 2502 (flush _test-error-buffered-file) - 2503 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2509 # check output - 2510 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incorrect-compound-type: output should be empty") - 2511 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'x' is not right" "F - test-convert-function-call-with-inout-with-incorrect-compound-type: error message") - 2512 # don't restore from ebp - 2513 81 0/subop/add %esp 8/imm32 - 2514 # . epilogue - 2515 5d/pop-to-ebp - 2516 c3/return - 2517 - 2518 test-convert-function-call-with-inout-with-multiple-type-parameters: - 2519 # . prologue - 2520 55/push-ebp - 2521 89/<- %ebp 4/r32/esp - 2522 # setup - 2523 (clear-stream _test-input-stream) - 2524 (clear-stream $_test-input-buffered-file->buffer) - 2525 (clear-stream _test-output-stream) - 2526 (clear-stream $_test-output-buffered-file->buffer) - 2527 (clear-stream _test-error-stream) - 2528 (clear-stream $_test-error-buffered-file->buffer) - 2529 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2530 68/push 0/imm32 - 2531 68/push 0/imm32 - 2532 89/<- %edx 4/r32/esp - 2533 (tailor-exit-descriptor %edx 0x10) - 2534 # - 2535 (write _test-input-stream "fn f {\n") - 2536 (write _test-input-stream " var x: (addr int)\n") - 2537 (write _test-input-stream " var y: (addr int)\n") - 2538 (write _test-input-stream " g x, y\n") - 2539 (write _test-input-stream "}\n") - 2540 (write _test-input-stream "fn g a: (addr _), b: (addr _) {\n") - 2541 (write _test-input-stream "}\n") - 2542 # convert - 2543 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2544 # registers except esp clobbered at this point - 2545 # restore ed - 2546 89/<- %edx 4/r32/esp - 2547 (flush _test-output-buffered-file) - 2548 (flush _test-error-buffered-file) - 2549 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2555 # no errors - 2556 (check-stream-equal _test-error-stream "" "F - test-convert-function-call-with-inout-with-multiple-type-parameters: error stream should be empty") - 2557 # don't bother checking the generated code - 2558 # don't restore from ebp - 2559 81 0/subop/add %esp 8/imm32 - 2560 # . epilogue - 2561 5d/pop-to-ebp - 2562 c3/return - 2563 - 2564 test-type-parameter-matches-rest-of-type: - 2565 # . prologue - 2566 55/push-ebp - 2567 89/<- %ebp 4/r32/esp - 2568 # setup - 2569 (clear-stream _test-input-stream) - 2570 (clear-stream $_test-input-buffered-file->buffer) - 2571 (clear-stream _test-output-stream) - 2572 (clear-stream $_test-output-buffered-file->buffer) - 2573 (clear-stream _test-error-stream) - 2574 (clear-stream $_test-error-buffered-file->buffer) - 2575 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2576 68/push 0/imm32 - 2577 68/push 0/imm32 - 2578 89/<- %edx 4/r32/esp - 2579 (tailor-exit-descriptor %edx 0x10) - 2580 # - 2581 (write _test-input-stream "fn f {\n") - 2582 (write _test-input-stream " var x: (addr array int)\n") - 2583 (write _test-input-stream " g x\n") - 2584 (write _test-input-stream "}\n") - 2585 (write _test-input-stream "fn g a: (addr _) {\n") - 2586 (write _test-input-stream "}\n") - 2587 # convert - 2588 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2589 # registers except esp clobbered at this point - 2590 # restore ed - 2591 89/<- %edx 4/r32/esp - 2592 (flush _test-output-buffered-file) - 2593 (flush _test-error-buffered-file) - 2594 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2600 # no errors - 2601 (check-stream-equal _test-error-stream "" "F - test-type-parameter-matches-rest-of-type: error stream should be empty") - 2602 # don't bother checking the generated code - 2603 # don't restore from ebp - 2604 81 0/subop/add %esp 8/imm32 - 2605 # . epilogue - 2606 5d/pop-to-ebp - 2607 c3/return - 2608 - 2609 test-convert-function-call-with-inout-with-incompatible-type-parameters: - 2610 # . prologue - 2611 55/push-ebp - 2612 89/<- %ebp 4/r32/esp - 2613 # setup - 2614 (clear-stream _test-input-stream) - 2615 (clear-stream $_test-input-buffered-file->buffer) - 2616 (clear-stream _test-output-stream) - 2617 (clear-stream $_test-output-buffered-file->buffer) - 2618 (clear-stream _test-error-stream) - 2619 (clear-stream $_test-error-buffered-file->buffer) - 2620 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2621 68/push 0/imm32 - 2622 68/push 0/imm32 - 2623 89/<- %edx 4/r32/esp - 2624 (tailor-exit-descriptor %edx 0x10) - 2625 # - 2626 (write _test-input-stream "fn f {\n") - 2627 (write _test-input-stream " var x: (addr int)\n") - 2628 (write _test-input-stream " var y: (addr boolean)\n") - 2629 (write _test-input-stream " g x, y\n") - 2630 (write _test-input-stream "}\n") - 2631 (write _test-input-stream "fn g a: (addr _T), b: (addr _T) {\n") - 2632 (write _test-input-stream "}\n") - 2633 # convert - 2634 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2635 # registers except esp clobbered at this point - 2636 # restore ed - 2637 89/<- %edx 4/r32/esp - 2638 (flush _test-output-buffered-file) - 2639 (flush _test-error-buffered-file) - 2640 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2646 # check output - 2647 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: output should be empty") - 2648 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'y' is not right" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: error message") - 2649 # don't restore from ebp - 2650 81 0/subop/add %esp 8/imm32 - 2651 # . epilogue - 2652 5d/pop-to-ebp - 2653 c3/return - 2654 - 2655 test-convert-function-call-with-too-few-inouts: - 2656 # . prologue - 2657 55/push-ebp - 2658 89/<- %ebp 4/r32/esp - 2659 # setup - 2660 (clear-stream _test-input-stream) - 2661 (clear-stream $_test-input-buffered-file->buffer) - 2662 (clear-stream _test-output-stream) - 2663 (clear-stream $_test-output-buffered-file->buffer) - 2664 (clear-stream _test-error-stream) - 2665 (clear-stream $_test-error-buffered-file->buffer) - 2666 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2667 68/push 0/imm32 - 2668 68/push 0/imm32 - 2669 89/<- %edx 4/r32/esp - 2670 (tailor-exit-descriptor %edx 0x10) - 2671 # - 2672 (write _test-input-stream "fn f {\n") - 2673 (write _test-input-stream " g\n") - 2674 (write _test-input-stream "}\n") - 2675 (write _test-input-stream "fn g a: int {\n") - 2676 (write _test-input-stream "}\n") - 2677 # convert - 2678 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2679 # registers except esp clobbered at this point - 2680 # restore ed - 2681 89/<- %edx 4/r32/esp - 2682 (flush _test-output-buffered-file) - 2683 (flush _test-error-buffered-file) - 2684 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2690 # check output - 2691 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-inouts: output should be empty") - 2692 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few inouts" "F - test-convert-function-call-with-too-few-inouts: error message") - 2693 # check that stop(1) was called - 2694 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-inouts: exit status") - 2695 # don't restore from ebp - 2696 81 0/subop/add %esp 8/imm32 - 2697 5d/pop-to-ebp - 2698 c3/return - 2699 - 2700 test-convert-function-call-with-too-many-inouts: - 2701 # . prologue - 2702 55/push-ebp - 2703 89/<- %ebp 4/r32/esp - 2704 # setup - 2705 (clear-stream _test-input-stream) - 2706 (clear-stream $_test-input-buffered-file->buffer) - 2707 (clear-stream _test-output-stream) - 2708 (clear-stream $_test-output-buffered-file->buffer) - 2709 (clear-stream _test-error-stream) - 2710 (clear-stream $_test-error-buffered-file->buffer) - 2711 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2712 68/push 0/imm32 - 2713 68/push 0/imm32 - 2714 89/<- %edx 4/r32/esp - 2715 (tailor-exit-descriptor %edx 0x10) - 2716 # - 2717 (write _test-input-stream "fn f {\n") - 2718 (write _test-input-stream " var x: int\n") - 2719 (write _test-input-stream " g x\n") - 2720 (write _test-input-stream "}\n") - 2721 (write _test-input-stream "fn g {\n") - 2722 (write _test-input-stream "}\n") - 2723 # convert - 2724 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2725 # registers except esp clobbered at this point - 2726 # restore ed - 2727 89/<- %edx 4/r32/esp - 2728 (flush _test-output-buffered-file) - 2729 (flush _test-error-buffered-file) - 2730 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2736 # check output - 2737 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-inouts: output should be empty") - 2738 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many inouts" "F - test-convert-function-call-with-too-many-inouts: error message") - 2739 # check that stop(1) was called - 2740 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-inouts: exit status") - 2741 # don't restore from ebp - 2742 81 0/subop/add %esp 8/imm32 - 2743 5d/pop-to-ebp - 2744 c3/return - 2745 - 2746 test-convert-function-call-with-incorrect-output-type: - 2747 # . prologue - 2748 55/push-ebp - 2749 89/<- %ebp 4/r32/esp - 2750 # setup - 2751 (clear-stream _test-input-stream) - 2752 (clear-stream $_test-input-buffered-file->buffer) - 2753 (clear-stream _test-output-stream) - 2754 (clear-stream $_test-output-buffered-file->buffer) - 2755 (clear-stream _test-error-stream) - 2756 (clear-stream $_test-error-buffered-file->buffer) - 2757 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2758 68/push 0/imm32 - 2759 68/push 0/imm32 - 2760 89/<- %edx 4/r32/esp - 2761 (tailor-exit-descriptor %edx 0x10) - 2762 # - 2763 (write _test-input-stream "fn f {\n") - 2764 (write _test-input-stream " var x/eax: int <- g\n") - 2765 (write _test-input-stream "}\n") - 2766 (write _test-input-stream "fn g -> _/eax: foo {\n") - 2767 (write _test-input-stream "}\n") - 2768 # convert - 2769 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2770 # registers except esp clobbered at this point - 2771 # restore ed - 2772 89/<- %edx 4/r32/esp - 2773 (flush _test-output-buffered-file) - 2774 (flush _test-error-buffered-file) - 2775 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2781 # check output - 2782 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-type: output should be empty") - 2783 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-type: error message") - 2784 # check that stop(1) was called - 2785 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-type: exit status") - 2786 # don't restore from ebp - 2787 81 0/subop/add %esp 8/imm32 - 2788 5d/pop-to-ebp - 2789 c3/return - 2790 - 2791 test-convert-function-call-with-too-few-outputs: - 2792 # . prologue - 2793 55/push-ebp - 2794 89/<- %ebp 4/r32/esp - 2795 # setup - 2796 (clear-stream _test-input-stream) - 2797 (clear-stream $_test-input-buffered-file->buffer) - 2798 (clear-stream _test-output-stream) - 2799 (clear-stream $_test-output-buffered-file->buffer) - 2800 (clear-stream _test-error-stream) - 2801 (clear-stream $_test-error-buffered-file->buffer) - 2802 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2803 68/push 0/imm32 - 2804 68/push 0/imm32 - 2805 89/<- %edx 4/r32/esp - 2806 (tailor-exit-descriptor %edx 0x10) - 2807 # - 2808 (write _test-input-stream "fn f {\n") - 2809 (write _test-input-stream " g\n") - 2810 (write _test-input-stream "}\n") - 2811 (write _test-input-stream "fn g -> _/eax: int {\n") - 2812 (write _test-input-stream "}\n") - 2813 # convert - 2814 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2815 # registers except esp clobbered at this point - 2816 # restore ed - 2817 89/<- %edx 4/r32/esp - 2818 (flush _test-output-buffered-file) - 2819 (flush _test-error-buffered-file) - 2820 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2826 # check output - 2827 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-outputs: output should be empty") - 2828 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few outputs" "F - test-convert-function-call-with-too-few-outputs: error message") - 2829 # check that stop(1) was called - 2830 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-outputs: exit status") - 2831 # don't restore from ebp - 2832 81 0/subop/add %esp 8/imm32 - 2833 5d/pop-to-ebp - 2834 c3/return - 2835 - 2836 test-convert-function-call-with-too-many-outputs: - 2837 # . prologue - 2838 55/push-ebp - 2839 89/<- %ebp 4/r32/esp - 2840 # setup - 2841 (clear-stream _test-input-stream) - 2842 (clear-stream $_test-input-buffered-file->buffer) - 2843 (clear-stream _test-output-stream) - 2844 (clear-stream $_test-output-buffered-file->buffer) - 2845 (clear-stream _test-error-stream) - 2846 (clear-stream $_test-error-buffered-file->buffer) - 2847 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2848 68/push 0/imm32 - 2849 68/push 0/imm32 - 2850 89/<- %edx 4/r32/esp - 2851 (tailor-exit-descriptor %edx 0x10) - 2852 # - 2853 (write _test-input-stream "fn f {\n") - 2854 (write _test-input-stream " var x/eax: int <- g\n") - 2855 (write _test-input-stream "}\n") - 2856 (write _test-input-stream "fn g {\n") - 2857 (write _test-input-stream "}\n") - 2858 # convert - 2859 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2860 # registers except esp clobbered at this point - 2861 # restore ed - 2862 89/<- %edx 4/r32/esp - 2863 (flush _test-output-buffered-file) - 2864 (flush _test-error-buffered-file) - 2865 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2871 # check output - 2872 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-outputs: output should be empty") - 2873 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many outputs" "F - test-convert-function-call-with-too-many-outputs: error message") - 2874 # check that stop(1) was called - 2875 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-outputs: exit status") - 2876 # don't restore from ebp - 2877 81 0/subop/add %esp 8/imm32 - 2878 5d/pop-to-ebp - 2879 c3/return - 2880 - 2881 test-convert-function-call-with-missing-output-register: - 2882 # . prologue - 2883 55/push-ebp - 2884 89/<- %ebp 4/r32/esp - 2885 # setup - 2886 (clear-stream _test-input-stream) - 2887 (clear-stream $_test-input-buffered-file->buffer) - 2888 (clear-stream _test-output-stream) - 2889 (clear-stream $_test-output-buffered-file->buffer) - 2890 (clear-stream _test-error-stream) - 2891 (clear-stream $_test-error-buffered-file->buffer) - 2892 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2893 68/push 0/imm32 - 2894 68/push 0/imm32 - 2895 89/<- %edx 4/r32/esp - 2896 (tailor-exit-descriptor %edx 0x10) - 2897 # - 2898 (write _test-input-stream "fn f {\n") - 2899 (write _test-input-stream " var x: int\n") - 2900 (write _test-input-stream " x <- g\n") - 2901 (write _test-input-stream "}\n") - 2902 (write _test-input-stream "fn g -> _/eax: int {\n") - 2903 (write _test-input-stream "}\n") - 2904 # convert - 2905 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2906 # registers except esp clobbered at this point - 2907 # restore ed - 2908 89/<- %edx 4/r32/esp - 2909 (flush _test-output-buffered-file) - 2910 (flush _test-error-buffered-file) - 2911 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2917 # check output - 2918 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-missing-output-register: output should be empty") - 2919 (check-next-stream-line-equal _test-error-stream "fn f: call g: output 'x' is not in a register" "F - test-convert-function-call-with-missing-output-register: error message") - 2920 # check that stop(1) was called - 2921 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-missing-output-register: exit status") - 2922 # don't restore from ebp - 2923 81 0/subop/add %esp 8/imm32 - 2924 5d/pop-to-ebp - 2925 c3/return - 2926 - 2927 test-convert-function-call-with-incorrect-output-register: - 2928 # . prologue - 2929 55/push-ebp - 2930 89/<- %ebp 4/r32/esp - 2931 # setup - 2932 (clear-stream _test-input-stream) - 2933 (clear-stream $_test-input-buffered-file->buffer) - 2934 (clear-stream _test-output-stream) - 2935 (clear-stream $_test-output-buffered-file->buffer) - 2936 (clear-stream _test-error-stream) - 2937 (clear-stream $_test-error-buffered-file->buffer) - 2938 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 2939 68/push 0/imm32 - 2940 68/push 0/imm32 - 2941 89/<- %edx 4/r32/esp - 2942 (tailor-exit-descriptor %edx 0x10) - 2943 # - 2944 (write _test-input-stream "fn f {\n") - 2945 (write _test-input-stream " var x/ecx: int <- g\n") - 2946 (write _test-input-stream "}\n") - 2947 (write _test-input-stream "fn g -> _/eax: int {\n") - 2948 (write _test-input-stream "}\n") - 2949 # convert - 2950 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 2951 # registers except esp clobbered at this point - 2952 # restore ed - 2953 89/<- %edx 4/r32/esp - 2954 (flush _test-output-buffered-file) - 2955 (flush _test-error-buffered-file) - 2956 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2962 # check output - 2963 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-register: output should be empty") - 2964 (check-next-stream-line-equal _test-error-stream "fn f: call g: register for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-register: error message") - 2965 # check that stop(1) was called - 2966 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-register: exit status") - 2967 # don't restore from ebp - 2968 81 0/subop/add %esp 8/imm32 - 2969 5d/pop-to-ebp - 2970 c3/return - 2971 - 2972 test-convert-function-with-local-var-dereferenced: - 2973 # . prologue - 2974 55/push-ebp - 2975 89/<- %ebp 4/r32/esp - 2976 # setup - 2977 (clear-stream _test-input-stream) - 2978 (clear-stream $_test-input-buffered-file->buffer) - 2979 (clear-stream _test-output-stream) - 2980 (clear-stream $_test-output-buffered-file->buffer) - 2981 # - 2982 (write _test-input-stream "fn foo {\n") - 2983 (write _test-input-stream " var x/ecx: (addr int) <- copy 0\n") - 2984 (write _test-input-stream " increment *x\n") - 2985 (write _test-input-stream "}\n") - 2986 # convert - 2987 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 2988 (flush _test-output-buffered-file) - 2989 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 2995 # check output - 2996 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-dereferenced/0") - 2997 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-dereferenced/1") - 2998 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-dereferenced/2") - 2999 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-dereferenced/3") - 3000 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-dereferenced/4") - 3001 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-dereferenced/5") - 3002 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-local-var-dereferenced/6") - 3003 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-local-var-dereferenced/7") - 3004 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *ecx" "F - test-convert-function-with-local-var-dereferenced/8") - 3005 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-local-var-dereferenced/9") - 3006 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-dereferenced/10") - 3007 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-dereferenced/11") - 3008 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-dereferenced/12") - 3009 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-dereferenced/13") - 3010 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-dereferenced/14") - 3011 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-dereferenced/15") - 3012 # . epilogue - 3013 89/<- %esp 5/r32/ebp - 3014 5d/pop-to-ebp - 3015 c3/return - 3016 - 3017 test-dereference-of-var-on-stack: - 3018 # . prologue - 3019 55/push-ebp - 3020 89/<- %ebp 4/r32/esp - 3021 # setup - 3022 (clear-stream _test-input-stream) - 3023 (clear-stream $_test-input-buffered-file->buffer) - 3024 (clear-stream _test-output-stream) - 3025 (clear-stream $_test-output-buffered-file->buffer) - 3026 (clear-stream _test-error-stream) - 3027 (clear-stream $_test-error-buffered-file->buffer) - 3028 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 3029 68/push 0/imm32 - 3030 68/push 0/imm32 - 3031 89/<- %edx 4/r32/esp - 3032 (tailor-exit-descriptor %edx 0x10) - 3033 # - 3034 (write _test-input-stream "fn foo {\n") - 3035 (write _test-input-stream " var x: (addr int)\n") - 3036 (write _test-input-stream " increment *x\n") - 3037 (write _test-input-stream "}\n") - 3038 # convert - 3039 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 3040 # registers except esp clobbered at this point - 3041 # restore ed - 3042 89/<- %edx 4/r32/esp - 3043 (flush _test-output-buffered-file) - 3044 (flush _test-error-buffered-file) - 3045 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3051 # check output - 3052 (check-stream-equal _test-output-stream "" "F - test-dereference-of-var-on-stack: output should be empty") - 3053 (check-next-stream-line-equal _test-error-stream "fn foo: cannot dereference var 'x' on stack" "F - test-dereference-of-var-on-stack: error message") - 3054 # check that stop(1) was called - 3055 (check-ints-equal *(edx+4) 2 "F - test-dereference-of-var-on-stack: exit status") - 3056 # don't restore from ebp - 3057 81 0/subop/add %esp 8/imm32 - 3058 # . epilogue - 3059 5d/pop-to-ebp - 3060 c3/return - 3061 - 3062 # variables of type 'byte' are not allowed on the stack - 3063 test-convert-function-with-byte-operations: - 3064 # . prologue - 3065 55/push-ebp - 3066 89/<- %ebp 4/r32/esp - 3067 # setup - 3068 (clear-stream _test-input-stream) - 3069 (clear-stream $_test-input-buffered-file->buffer) - 3070 (clear-stream _test-output-stream) - 3071 (clear-stream $_test-output-buffered-file->buffer) - 3072 # - 3073 (write _test-input-stream "fn foo {\n") - 3074 (write _test-input-stream " var x/eax: byte <- copy 0\n") - 3075 (write _test-input-stream " var y/ecx: byte <- copy 0\n") - 3076 (write _test-input-stream " y <- copy-byte x\n") - 3077 (write _test-input-stream " var z/edx: (addr byte) <- copy 0\n") - 3078 (write _test-input-stream " y <- copy-byte *z\n") - 3079 (write _test-input-stream " copy-byte-to *z, x\n") - 3080 (write _test-input-stream "}\n") - 3081 # convert - 3082 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3083 (flush _test-output-buffered-file) - 3084 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3090 # check output - 3091 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-byte-operations/0") - 3092 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-byte-operations/1") - 3093 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-byte-operations/2") - 3094 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-byte-operations/3") - 3095 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-byte-operations/4") - 3096 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-byte-operations/5") - 3097 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-byte-operations/6") - 3098 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-byte-operations/7") - 3099 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-byte-operations/8") - 3100 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-byte-operations/9") - 3101 (check-next-stream-line-equal _test-output-stream " 8a/byte-> %eax 0x00000001/r32" "F - test-convert-function-with-byte-operations/10") - 3102 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-function-with-byte-operations/11") - 3103 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 0/imm32" "F - test-convert-function-with-byte-operations/12") - 3104 (check-next-stream-line-equal _test-output-stream " 8a/byte-> *edx 0x00000001/r32" "F - test-convert-function-with-byte-operations/13") - 3105 (check-next-stream-line-equal _test-output-stream " 88/byte<- *edx 0x00000000/r32" "F - test-convert-function-with-byte-operations/14") - 3106 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-function-with-byte-operations/15") - 3107 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-byte-operations/16") - 3108 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-byte-operations/17") - 3109 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-byte-operations/18") - 3110 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-byte-operations/19") - 3111 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-byte-operations/20") - 3112 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-byte-operations/21") - 3113 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-byte-operations/22") - 3114 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-byte-operations/23") - 3115 # . epilogue - 3116 89/<- %esp 5/r32/ebp - 3117 5d/pop-to-ebp - 3118 c3/return - 3119 - 3120 # variables of type 'byte' _can_ be function args. They then occupy 4 bytes. - 3121 test-copy-byte-var-from-fn-arg: - 3122 # . prologue - 3123 55/push-ebp - 3124 89/<- %ebp 4/r32/esp - 3125 # setup - 3126 (clear-stream _test-input-stream) - 3127 (clear-stream $_test-input-buffered-file->buffer) - 3128 (clear-stream _test-output-stream) - 3129 (clear-stream $_test-output-buffered-file->buffer) - 3130 # - 3131 (write _test-input-stream "fn foo x: byte, y: int {\n") - 3132 (write _test-input-stream " var a/eax: byte <- copy x\n") - 3133 (write _test-input-stream " var b/eax: int <- copy y\n") - 3134 (write _test-input-stream "}\n") - 3135 # convert - 3136 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3137 (flush _test-output-buffered-file) - 3138 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3144 # check output - 3145 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-copy-byte-from-fn-arg/0") - 3146 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-copy-byte-from-fn-arg/1") - 3147 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-copy-byte-from-fn-arg/2") - 3148 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-copy-byte-from-fn-arg/3") - 3149 (check-next-stream-line-equal _test-output-stream " {" "F - test-copy-byte-from-fn-arg/4") - 3150 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-copy-byte-from-fn-arg/5") - 3151 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-copy-byte-from-fn-arg/6") - 3152 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/7") - 3153 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x0000000c) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/8") - 3154 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-copy-byte-from-fn-arg/9") - 3155 (check-next-stream-line-equal _test-output-stream " }" "F - test-copy-byte-from-fn-arg/10") - 3156 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-copy-byte-from-fn-arg/11") - 3157 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-copy-byte-from-fn-arg/12") - 3158 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-copy-byte-from-fn-arg/13") - 3159 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-copy-byte-from-fn-arg/14") - 3160 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-copy-byte-from-fn-arg/15") - 3161 # . epilogue - 3162 89/<- %esp 5/r32/ebp - 3163 5d/pop-to-ebp - 3164 c3/return - 3165 - 3166 test-convert-compare-register-with-literal: - 3167 # . prologue - 3168 55/push-ebp - 3169 89/<- %ebp 4/r32/esp - 3170 # setup - 3171 (clear-stream _test-input-stream) - 3172 (clear-stream $_test-input-buffered-file->buffer) - 3173 (clear-stream _test-output-stream) - 3174 (clear-stream $_test-output-buffered-file->buffer) - 3175 # - 3176 (write _test-input-stream "fn foo {\n") - 3177 (write _test-input-stream " var x/ecx: int <- copy 0\n") - 3178 (write _test-input-stream " compare x, 0\n") - 3179 (write _test-input-stream "}\n") - 3180 # convert - 3181 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3182 (flush _test-output-buffered-file) - 3183 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3189 # check output - 3190 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-compare-register-with-literal/0") - 3191 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-compare-register-with-literal/1") - 3192 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-compare-register-with-literal/2") - 3193 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-compare-register-with-literal/3") - 3194 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-compare-register-with-literal/4") - 3195 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-compare-register-with-literal/5") - 3196 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6") - 3197 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-compare-register-with-literal/7") - 3198 (check-next-stream-line-equal _test-output-stream " 81 7/subop/compare %ecx 0/imm32" "F - test-convert-compare-register-with-literal/8") - 3199 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9") - 3200 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-compare-register-with-literal/10") - 3201 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-compare-register-with-literal/11") - 3202 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-compare-register-with-literal/12") - 3203 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-compare-register-with-literal/13") - 3204 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-compare-register-with-literal/14") - 3205 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-compare-register-with-literal/15") - 3206 # . epilogue - 3207 89/<- %esp 5/r32/ebp - 3208 5d/pop-to-ebp - 3209 c3/return - 3210 - 3211 test-unknown-variable: - 3212 # . prologue - 3213 55/push-ebp - 3214 89/<- %ebp 4/r32/esp - 3215 # setup - 3216 (clear-stream _test-input-stream) - 3217 (clear-stream $_test-input-buffered-file->buffer) - 3218 (clear-stream _test-output-stream) - 3219 (clear-stream $_test-output-buffered-file->buffer) - 3220 (clear-stream _test-error-stream) - 3221 (clear-stream $_test-error-buffered-file->buffer) - 3222 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 3223 68/push 0/imm32 - 3224 68/push 0/imm32 - 3225 89/<- %edx 4/r32/esp - 3226 (tailor-exit-descriptor %edx 0x10) - 3227 # - 3228 (write _test-input-stream "fn foo {\n") - 3229 (write _test-input-stream " compare x, 0\n") - 3230 (write _test-input-stream "}\n") - 3231 # convert - 3232 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 3233 # registers except esp clobbered at this point - 3234 # restore ed - 3235 89/<- %edx 4/r32/esp - 3236 (flush _test-output-buffered-file) - 3237 (flush _test-error-buffered-file) - 3238 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3244 # check output - 3245 (check-stream-equal _test-output-stream "" "F - test-unknown-variable: output should be empty") - 3246 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable: error message") - 3247 # check that stop(1) was called - 3248 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable: exit status") - 3249 # don't restore from ebp - 3250 81 0/subop/add %esp 8/imm32 - 3251 # . epilogue - 3252 5d/pop-to-ebp - 3253 c3/return - 3254 - 3255 test-convert-function-with-local-var-in-block: - 3256 # . prologue - 3257 55/push-ebp - 3258 89/<- %ebp 4/r32/esp - 3259 # setup - 3260 (clear-stream _test-input-stream) - 3261 (clear-stream $_test-input-buffered-file->buffer) - 3262 (clear-stream _test-output-stream) - 3263 (clear-stream $_test-output-buffered-file->buffer) - 3264 # - 3265 (write _test-input-stream "fn foo {\n") - 3266 (write _test-input-stream " {\n") - 3267 (write _test-input-stream " var x: int\n") - 3268 (write _test-input-stream " increment x\n") - 3269 (write _test-input-stream " }\n") - 3270 (write _test-input-stream "}\n") - 3271 # convert - 3272 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3273 (flush _test-output-buffered-file) - 3274 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3280 # check output - 3281 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-block/0") - 3282 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-block/1") - 3283 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-block/2") - 3284 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-block/3") - 3285 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/4") - 3286 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-block/5") - 3287 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/6") - 3288 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-local-var-in-block/7") - 3289 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-block/8") - 3290 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-block/9") - 3291 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-block/10") - 3292 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/11") - 3293 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-local-var-in-block/12") - 3294 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/13") - 3295 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-block/14") - 3296 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-block/15") - 3297 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-block/16") - 3298 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-block/17") - 3299 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-block/18") - 3300 # . epilogue - 3301 89/<- %esp 5/r32/ebp - 3302 5d/pop-to-ebp - 3303 c3/return - 3304 - 3305 test-convert-function-with-local-var-in-mem-after-block: - 3306 # . prologue - 3307 55/push-ebp - 3308 89/<- %ebp 4/r32/esp - 3309 # setup - 3310 (clear-stream _test-input-stream) - 3311 (clear-stream $_test-input-buffered-file->buffer) - 3312 (clear-stream _test-output-stream) - 3313 (clear-stream $_test-output-buffered-file->buffer) - 3314 # - 3315 (write _test-input-stream "fn foo {\n") - 3316 (write _test-input-stream " {\n") - 3317 (write _test-input-stream " var y: int\n") - 3318 (write _test-input-stream " }\n") - 3319 (write _test-input-stream " var x: int\n") - 3320 (write _test-input-stream " increment x\n") - 3321 (write _test-input-stream "}\n") - 3322 # convert - 3323 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3324 (flush _test-output-buffered-file) - 3325 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3331 # check output - 3332 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-mem-after-block/0") - 3333 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-mem-after-block/1") - 3334 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-mem-after-block/2") - 3335 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-mem-after-block/3") - 3336 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-mem-after-block/4") - 3337 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-mem-after-block/5") - 3338 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-mem-after-block/6") - 3339 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-local-var-in-mem-after-block/7") - 3340 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/8") - 3341 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/9") - 3342 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-mem-after-block/10") - 3343 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-local-var-in-mem-after-block/11") - 3344 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/12") - 3345 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-mem-after-block/13") - 3346 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/14") - 3347 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-mem-after-block/15") - 3348 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-mem-after-block/16") - 3349 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-mem-after-block/17") - 3350 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-mem-after-block/18") - 3351 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-mem-after-block/19") - 3352 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-mem-after-block/20") - 3353 # . epilogue - 3354 89/<- %esp 5/r32/ebp - 3355 5d/pop-to-ebp - 3356 c3/return - 3357 - 3358 test-convert-function-with-local-var-in-named-block: - 3359 # . prologue - 3360 55/push-ebp - 3361 89/<- %ebp 4/r32/esp - 3362 # setup - 3363 (clear-stream _test-input-stream) - 3364 (clear-stream $_test-input-buffered-file->buffer) - 3365 (clear-stream _test-output-stream) - 3366 (clear-stream $_test-output-buffered-file->buffer) - 3367 # - 3368 (write _test-input-stream "fn foo {\n") - 3369 (write _test-input-stream " $bar: {\n") - 3370 (write _test-input-stream " var x: int\n") - 3371 (write _test-input-stream " increment x\n") - 3372 (write _test-input-stream " }\n") - 3373 (write _test-input-stream "}\n") - 3374 # convert - 3375 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3376 (flush _test-output-buffered-file) - 3377 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3383 # check output - 3384 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-named-block/0") - 3385 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-named-block/1") - 3386 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-named-block/2") - 3387 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-named-block/3") - 3388 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/4") - 3389 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-named-block/5") - 3390 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/6") - 3391 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-local-var-in-named-block/7") - 3392 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-named-block/8") - 3393 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-named-block/9") - 3394 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-named-block/10") - 3395 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/11") - 3396 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-local-var-in-named-block/12") - 3397 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/13") - 3398 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-named-block/14") - 3399 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-named-block/15") - 3400 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-named-block/16") - 3401 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-named-block/17") - 3402 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-named-block/18") - 3403 # . epilogue - 3404 89/<- %esp 5/r32/ebp - 3405 5d/pop-to-ebp - 3406 c3/return - 3407 - 3408 test-unknown-variable-in-named-block: - 3409 # . prologue - 3410 55/push-ebp - 3411 89/<- %ebp 4/r32/esp - 3412 # setup - 3413 (clear-stream _test-input-stream) - 3414 (clear-stream $_test-input-buffered-file->buffer) - 3415 (clear-stream _test-output-stream) - 3416 (clear-stream $_test-output-buffered-file->buffer) - 3417 (clear-stream _test-error-stream) - 3418 (clear-stream $_test-error-buffered-file->buffer) - 3419 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 3420 68/push 0/imm32 - 3421 68/push 0/imm32 - 3422 89/<- %edx 4/r32/esp - 3423 (tailor-exit-descriptor %edx 0x10) - 3424 # - 3425 (write _test-input-stream "fn foo {\n") - 3426 (write _test-input-stream " $a: {\n") - 3427 (write _test-input-stream " compare x, 0\n") - 3428 (write _test-input-stream " }\n") - 3429 (write _test-input-stream "}\n") - 3430 # convert - 3431 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 3432 # registers except esp clobbered at this point - 3433 # restore ed - 3434 89/<- %edx 4/r32/esp - 3435 (flush _test-output-buffered-file) - 3436 (flush _test-error-buffered-file) - 3437 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3443 # check output - 3444 (check-stream-equal _test-output-stream "" "F - test-unknown-variable-in-named-block: output should be empty") - 3445 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable-in-named-block: error message") - 3446 # check that stop(1) was called - 3447 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable-in-named-block: exit status") - 3448 # don't restore from ebp - 3449 81 0/subop/add %esp 8/imm32 - 3450 # . epilogue - 3451 5d/pop-to-ebp - 3452 c3/return - 3453 - 3454 test-always-shadow-outermost-reg-vars-in-function: - 3455 # . prologue - 3456 55/push-ebp - 3457 89/<- %ebp 4/r32/esp - 3458 # setup - 3459 (clear-stream _test-input-stream) - 3460 (clear-stream $_test-input-buffered-file->buffer) - 3461 (clear-stream _test-output-stream) - 3462 (clear-stream $_test-output-buffered-file->buffer) - 3463 # - 3464 (write _test-input-stream "fn foo {\n") - 3465 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 3466 (write _test-input-stream "}\n") - 3467 # convert - 3468 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3469 (flush _test-output-buffered-file) - 3470 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3476 # check output - 3477 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-always-shadow-outermost-reg-vars-in-function/0") - 3478 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-always-shadow-outermost-reg-vars-in-function/1") - 3479 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/2") - 3480 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-always-shadow-outermost-reg-vars-in-function/3") - 3481 (check-next-stream-line-equal _test-output-stream " {" "F - test-always-shadow-outermost-reg-vars-in-function/4") - 3482 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-always-shadow-outermost-reg-vars-in-function/5") - 3483 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6") - 3484 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-always-shadow-outermost-reg-vars-in-function/8") - 3485 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9") - 3486 (check-next-stream-line-equal _test-output-stream " }" "F - test-always-shadow-outermost-reg-vars-in-function/12") - 3487 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-always-shadow-outermost-reg-vars-in-function/13") - 3488 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-always-shadow-outermost-reg-vars-in-function/14") - 3489 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-always-shadow-outermost-reg-vars-in-function/15") - 3490 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/16") - 3491 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-always-shadow-outermost-reg-vars-in-function/17") - 3492 # . epilogue - 3493 89/<- %esp 5/r32/ebp - 3494 5d/pop-to-ebp - 3495 c3/return - 3496 - 3497 test-shadow-local: - 3498 # . prologue - 3499 55/push-ebp - 3500 89/<- %ebp 4/r32/esp - 3501 # setup - 3502 (clear-stream _test-input-stream) - 3503 (clear-stream $_test-input-buffered-file->buffer) - 3504 (clear-stream _test-output-stream) - 3505 (clear-stream $_test-output-buffered-file->buffer) - 3506 # - 3507 (write _test-input-stream "fn foo {\n") - 3508 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 3509 (write _test-input-stream " {\n") - 3510 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 3511 (write _test-input-stream " }\n") - 3512 (write _test-input-stream " x <- increment\n") - 3513 (write _test-input-stream "}\n") - 3514 # convert - 3515 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3516 (flush _test-output-buffered-file) - 3517 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3523 # check output - 3524 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-local/0") - 3525 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-local/1") - 3526 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-local/2") - 3527 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-local/3") - 3528 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-local/4") - 3529 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-local/5") - 3530 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-local/6") - 3531 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-local/7") - 3532 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-local/8") - 3533 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-local/9") - 3534 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-local/10") - 3535 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-shadow-local/11") - 3536 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-local/12") - 3537 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-local/13") - 3538 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-local/14") - 3539 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-local/15") - 3540 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-local/16") - 3541 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-local/17") - 3542 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-local/18") - 3543 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-local/19") - 3544 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-local/20") - 3545 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-local/21") - 3546 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-local/22") - 3547 # . epilogue - 3548 89/<- %esp 5/r32/ebp - 3549 5d/pop-to-ebp - 3550 c3/return - 3551 - 3552 test-shadow-name: - 3553 # . prologue - 3554 55/push-ebp - 3555 89/<- %ebp 4/r32/esp - 3556 # setup - 3557 (clear-stream _test-input-stream) - 3558 (clear-stream $_test-input-buffered-file->buffer) - 3559 (clear-stream _test-output-stream) - 3560 (clear-stream $_test-output-buffered-file->buffer) - 3561 # - 3562 (write _test-input-stream "fn foo {\n") - 3563 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 3564 (write _test-input-stream " {\n") - 3565 (write _test-input-stream " var x/edx: int <- copy 4\n") - 3566 (write _test-input-stream " }\n") - 3567 (write _test-input-stream " x <- increment\n") - 3568 (write _test-input-stream "}\n") - 3569 # convert - 3570 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3571 (flush _test-output-buffered-file) - 3572 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3578 # check output - 3579 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name/0") - 3580 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name/1") - 3581 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name/2") - 3582 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name/3") - 3583 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/4") - 3584 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name/5") - 3585 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name/6") - 3586 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name/7") - 3587 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/8") - 3588 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name/9") - 3589 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name/10") - 3590 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name/11") - 3591 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name/12") - 3592 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/13") - 3593 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name/14") - 3594 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name/15") - 3595 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name/16") - 3596 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/17") - 3597 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name/18") - 3598 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name/19") - 3599 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name/20") - 3600 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name/21") - 3601 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name/22") - 3602 # . epilogue - 3603 89/<- %esp 5/r32/ebp - 3604 5d/pop-to-ebp - 3605 c3/return - 3606 - 3607 test-shadow-name-2: - 3608 # . prologue - 3609 55/push-ebp - 3610 89/<- %ebp 4/r32/esp - 3611 # setup - 3612 (clear-stream _test-input-stream) - 3613 (clear-stream $_test-input-buffered-file->buffer) - 3614 (clear-stream _test-output-stream) - 3615 (clear-stream $_test-output-buffered-file->buffer) - 3616 # - 3617 (write _test-input-stream "fn foo {\n") - 3618 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 3619 (write _test-input-stream " {\n") - 3620 (write _test-input-stream " var x/edx: int <- copy 4\n") - 3621 (write _test-input-stream " var y/ecx: int <- copy 5\n") - 3622 (write _test-input-stream " }\n") - 3623 (write _test-input-stream " x <- increment\n") - 3624 (write _test-input-stream "}\n") - 3625 # convert - 3626 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3627 (flush _test-output-buffered-file) - 3628 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3634 # check output - 3635 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name-2/0") - 3636 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name-2/1") - 3637 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name-2/2") - 3638 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name-2/3") - 3639 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/4") - 3640 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name-2/5") - 3641 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/6") - 3642 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name-2/7") - 3643 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/8") - 3644 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name-2/9") - 3645 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name-2/10") - 3646 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name-2/11") - 3647 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/12") - 3648 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 5/imm32" "F - test-shadow-name-2/13") - 3649 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/14") - 3650 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name-2/15") - 3651 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/16") - 3652 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name-2/17") - 3653 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name-2/18") - 3654 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/19") - 3655 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/20") - 3656 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name-2/21") - 3657 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name-2/22") - 3658 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name-2/23") - 3659 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name-2/24") - 3660 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name-2/25") - 3661 # . epilogue - 3662 89/<- %esp 5/r32/ebp - 3663 5d/pop-to-ebp - 3664 c3/return - 3665 - 3666 test-do-not-spill-same-register-in-block: - 3667 # . prologue - 3668 55/push-ebp - 3669 89/<- %ebp 4/r32/esp - 3670 # setup - 3671 (clear-stream _test-input-stream) - 3672 (clear-stream $_test-input-buffered-file->buffer) - 3673 (clear-stream _test-output-stream) - 3674 (clear-stream $_test-output-buffered-file->buffer) - 3675 # - 3676 (write _test-input-stream "fn foo {\n") - 3677 (write _test-input-stream " var x/ecx: int <- copy 3\n") - 3678 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 3679 (write _test-input-stream " y <- increment\n") - 3680 (write _test-input-stream "}\n") - 3681 # convert - 3682 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3683 (flush _test-output-buffered-file) - 3684 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3690 # check output - 3691 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-do-not-spill-same-register-in-block/0") - 3692 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-do-not-spill-same-register-in-block/1") - 3693 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-do-not-spill-same-register-in-block/2") - 3694 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-do-not-spill-same-register-in-block/3") - 3695 (check-next-stream-line-equal _test-output-stream " {" "F - test-do-not-spill-same-register-in-block/4") - 3696 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-do-not-spill-same-register-in-block/5") - 3697 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-do-not-spill-same-register-in-block/6") - 3698 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-do-not-spill-same-register-in-block/7") - 3699 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-do-not-spill-same-register-in-block/8") - 3700 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-do-not-spill-same-register-in-block/9") - 3701 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-do-not-spill-same-register-in-block/10") - 3702 (check-next-stream-line-equal _test-output-stream " }" "F - test-do-not-spill-same-register-in-block/11") - 3703 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-do-not-spill-same-register-in-block/12") - 3704 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-do-not-spill-same-register-in-block/13") - 3705 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-do-not-spill-same-register-in-block/14") - 3706 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-do-not-spill-same-register-in-block/15") - 3707 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-do-not-spill-same-register-in-block/16") - 3708 # . epilogue - 3709 89/<- %esp 5/r32/ebp - 3710 5d/pop-to-ebp - 3711 c3/return - 3712 - 3713 test-spill-different-register-in-block: - 3714 # . prologue - 3715 55/push-ebp - 3716 89/<- %ebp 4/r32/esp - 3717 # setup - 3718 (clear-stream _test-input-stream) - 3719 (clear-stream $_test-input-buffered-file->buffer) - 3720 (clear-stream _test-output-stream) - 3721 (clear-stream $_test-output-buffered-file->buffer) - 3722 # - 3723 (write _test-input-stream "fn foo {\n") - 3724 (write _test-input-stream " var x/eax: int <- copy 3\n") - 3725 (write _test-input-stream " var y/ecx: int <- copy 4\n") - 3726 (write _test-input-stream " y <- increment\n") - 3727 (write _test-input-stream "}\n") - 3728 # convert - 3729 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3730 (flush _test-output-buffered-file) - 3731 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3737 # check output - 3738 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-spill-different-register-in-block/0") - 3739 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-spill-different-register-in-block/1") - 3740 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-spill-different-register-in-block/2") - 3741 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-spill-different-register-in-block/3") - 3742 (check-next-stream-line-equal _test-output-stream " {" "F - test-spill-different-register-in-block/4") - 3743 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-spill-different-register-in-block/5") - 3744 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-spill-different-register-in-block/6") - 3745 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-spill-different-register-in-block/7") - 3746 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-spill-different-register-in-block/8") - 3747 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-spill-different-register-in-block/9") - 3748 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-spill-different-register-in-block/10") - 3749 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-spill-different-register-in-block/11") - 3750 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-spill-different-register-in-block/12") - 3751 (check-next-stream-line-equal _test-output-stream " }" "F - test-spill-different-register-in-block/13") - 3752 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-spill-different-register-in-block/14") - 3753 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-spill-different-register-in-block/15") - 3754 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-spill-different-register-in-block/16") - 3755 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-spill-different-register-in-block/17") - 3756 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-spill-different-register-in-block/18") - 3757 # . epilogue - 3758 89/<- %esp 5/r32/ebp - 3759 5d/pop-to-ebp - 3760 c3/return - 3761 - 3762 test-convert-function-with-branches-in-block: - 3763 # . prologue - 3764 55/push-ebp - 3765 89/<- %ebp 4/r32/esp - 3766 # setup - 3767 (clear-stream _test-input-stream) - 3768 (clear-stream $_test-input-buffered-file->buffer) - 3769 (clear-stream _test-output-stream) - 3770 (clear-stream $_test-output-buffered-file->buffer) - 3771 # - 3772 (write _test-input-stream "fn foo x: int {\n") - 3773 (write _test-input-stream " {\n") - 3774 (write _test-input-stream " break-if->=\n") - 3775 (write _test-input-stream " loop-if-addr<\n") - 3776 (write _test-input-stream " increment x\n") - 3777 (write _test-input-stream " loop\n") - 3778 (write _test-input-stream " }\n") - 3779 (write _test-input-stream "}\n") - 3780 # convert - 3781 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3782 (flush _test-output-buffered-file) - 3783 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3789 # check output - 3790 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0") - 3791 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1") - 3792 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-block/2") - 3793 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-block/3") - 3794 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/4") - 3795 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-block/5") - 3796 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/6") - 3797 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-in-block/7") - 3798 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/8") - 3799 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-block/9") - 3800 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-in-block/10") - 3801 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/11") - 3802 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/12") - 3803 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-block/13") - 3804 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-branches-in-block/14") - 3805 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/15") - 3806 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-block/16") - 3807 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-block/17") - 3808 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/18") - 3809 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-in-block/19") - 3810 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/20") - 3811 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-block/21") - 3812 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-block/22") - 3813 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-block/23") - 3814 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-block/24") - 3815 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-block/25") - 3816 # . epilogue - 3817 89/<- %esp 5/r32/ebp - 3818 5d/pop-to-ebp - 3819 c3/return - 3820 - 3821 test-convert-function-with-branches-in-block-2: - 3822 # . prologue - 3823 55/push-ebp - 3824 89/<- %ebp 4/r32/esp - 3825 # setup - 3826 (clear-stream _test-input-stream) - 3827 (clear-stream $_test-input-buffered-file->buffer) - 3828 (clear-stream _test-output-stream) - 3829 (clear-stream $_test-output-buffered-file->buffer) - 3830 # - 3831 (write _test-input-stream "fn foo x: int {\n") - 3832 (write _test-input-stream " {\n") - 3833 (write _test-input-stream " break-if->=\n") - 3834 (write _test-input-stream " loop-if-float<\n") - 3835 (write _test-input-stream " increment x\n") - 3836 (write _test-input-stream " loop\n") + 1970 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg/0") + 1971 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg/1") + 1972 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-literal-arg/2") + 1973 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-literal-arg/3") + 1974 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-literal-arg/4") + 1975 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-literal-arg/5") + 1976 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-literal-arg/6") + 1977 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-with-literal-arg/7") + 1978 (check-next-stream-line-equal _test-output-stream " 05/add-to-eax 1/imm32" "F - test-convert-function-with-literal-arg/8") + 1979 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-with-literal-arg/9") + 1980 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-literal-arg/10") + 1981 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-literal-arg/11") + 1982 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-literal-arg/12") + 1983 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-literal-arg/13") + 1984 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-literal-arg/14") + 1985 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-literal-arg/15") + 1986 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-literal-arg/16") + 1987 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-literal-arg/17") + 1988 # . epilogue + 1989 89/<- %esp 5/r32/ebp + 1990 5d/pop-to-ebp + 1991 c3/return + 1992 + 1993 test-convert-function-with-literal-arg-2: + 1994 # . prologue + 1995 55/push-ebp + 1996 89/<- %ebp 4/r32/esp + 1997 # setup + 1998 (clear-stream _test-input-stream) + 1999 (clear-stream $_test-input-buffered-file->buffer) + 2000 (clear-stream _test-output-stream) + 2001 (clear-stream $_test-output-buffered-file->buffer) + 2002 # + 2003 (write _test-input-stream "fn foo a: int, b: int -> _/ebx: int {\n") + 2004 (write _test-input-stream " var result/ebx: int <- copy a\n") + 2005 (write _test-input-stream " result <- add 1\n") + 2006 (write _test-input-stream " return result\n") + 2007 (write _test-input-stream "}\n") + 2008 # convert + 2009 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2010 (flush _test-output-buffered-file) + 2011 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2017 # check output + 2018 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-literal-arg-2/0") + 2019 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-literal-arg-2/1") + 2020 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-literal-arg-2/2") + 2021 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-literal-arg-2/3") + 2022 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-literal-arg-2/4") + 2023 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-literal-arg-2/5") + 2024 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-function-with-literal-arg-2/6") + 2025 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000003/r32" "F - test-convert-function-with-literal-arg-2/7") + 2026 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %ebx 1/imm32" "F - test-convert-function-with-literal-arg-2/8") + 2027 (check-next-stream-line-equal _test-output-stream " 8b/-> %ebx 0x00000003/r32" "F - test-convert-function-with-literal-arg-2/9") + 2028 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-literal-arg-2/10") + 2029 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-literal-arg-2/11") + 2030 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-literal-arg-2/12") + 2031 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-literal-arg-2/13") + 2032 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-literal-arg-2/14") + 2033 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-literal-arg-2/15") + 2034 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-literal-arg-2/16") + 2035 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-literal-arg-2/17") + 2036 # . epilogue + 2037 89/<- %esp 5/r32/ebp + 2038 5d/pop-to-ebp + 2039 c3/return + 2040 + 2041 test-convert-function-call-with-literal-arg: + 2042 # . prologue + 2043 55/push-ebp + 2044 89/<- %ebp 4/r32/esp + 2045 # setup + 2046 (clear-stream _test-input-stream) + 2047 (clear-stream $_test-input-buffered-file->buffer) + 2048 (clear-stream _test-output-stream) + 2049 (clear-stream $_test-output-buffered-file->buffer) + 2050 # + 2051 (write _test-input-stream "fn main -> _/ebx: int {\n") + 2052 (write _test-input-stream " var result/eax: int <- do-add 3 4\n") + 2053 (write _test-input-stream " return result\n") + 2054 (write _test-input-stream "}\n") + 2055 (write _test-input-stream "fn do-add a: int, b: int -> _/eax: int {\n") + 2056 (write _test-input-stream " var result/eax: int <- copy a\n") + 2057 (write _test-input-stream " result <- add b\n") + 2058 (write _test-input-stream " return result\n") + 2059 (write _test-input-stream "}\n") + 2060 # convert + 2061 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2062 (flush _test-output-buffered-file) + 2063 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2069 # check output + 2070 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call-with-literal-arg/0") + 2071 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-literal-arg/1") + 2072 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-literal-arg/2") + 2073 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-literal-arg/3") + 2074 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-literal-arg/4") + 2075 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:loop:" "F - test-convert-function-call-with-literal-arg/5") + 2076 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-literal-arg/6") + 2077 (check-next-stream-line-equal _test-output-stream " (do-add 3 4)" "F - test-convert-function-call-with-literal-arg/7") + 2078 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8") + 2079 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-local-var-in-reg/9") + 2080 (check-next-stream-line-equal _test-output-stream " e9/jump $main:0x00000001:break/disp32" "F - test-convert-function-call-with-literal-arg/10") + 2081 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-literal-arg/11") + 2082 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:break:" "F - test-convert-function-call-with-literal-arg/12") + 2083 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-literal-arg/13") + 2084 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-literal-arg/14") + 2085 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-literal-arg/15") + 2086 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-literal-arg/16") + 2087 (check-next-stream-line-equal _test-output-stream "do-add:" "F - test-convert-function-call-with-literal-arg/17") + 2088 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-literal-arg/18") + 2089 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-literal-arg/19") + 2090 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-literal-arg/20") + 2091 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-literal-arg/21") + 2092 (check-next-stream-line-equal _test-output-stream "$do-add:0x00000002:loop:" "F - test-convert-function-call-with-literal-arg/22") + 2093 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-literal-arg/23") + 2094 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-call-with-literal-arg/24") + 2095 (check-next-stream-line-equal _test-output-stream " 03/add *(ebp+0x0000000c) 0x00000000/r32" "F - test-convert-function-call-with-literal-arg/25") + 2096 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-call-with-literal-arg/26") + 2097 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-call-with-literal-arg/27") + 2098 (check-next-stream-line-equal _test-output-stream " e9/jump $do-add:0x00000002:break/disp32" "F - test-convert-function-call-with-literal-arg/28") + 2099 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-literal-arg/29") + 2100 (check-next-stream-line-equal _test-output-stream "$do-add:0x00000002:break:" "F - test-convert-function-call-with-literal-arg/30") + 2101 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-literal-arg/31") + 2102 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-literal-arg/32") + 2103 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-literal-arg/33") + 2104 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-literal-arg/34") + 2105 # . epilogue + 2106 89/<- %esp 5/r32/ebp + 2107 5d/pop-to-ebp + 2108 c3/return + 2109 + 2110 test-convert-function-call-with-literal-string-arg: + 2111 # . prologue + 2112 55/push-ebp + 2113 89/<- %ebp 4/r32/esp + 2114 # setup + 2115 (clear-stream _test-input-stream) + 2116 (clear-stream $_test-input-buffered-file->buffer) + 2117 (clear-stream _test-output-stream) + 2118 (clear-stream $_test-output-buffered-file->buffer) + 2119 # + 2120 (write _test-input-stream "fn foo {\n") + 2121 (write _test-input-stream " string-func \"abc\"\n") + 2122 (write _test-input-stream "}\n") + 2123 (write _test-input-stream "sig string-func in: (addr array byte)\n") + 2124 # convert + 2125 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2126 # no errors + 2127 # not bothering checking output + 2128 # . epilogue + 2129 89/<- %esp 5/r32/ebp + 2130 5d/pop-to-ebp + 2131 c3/return + 2132 + 2133 test-convert-function-call-with-null-addr: + 2134 # . prologue + 2135 55/push-ebp + 2136 89/<- %ebp 4/r32/esp + 2137 # setup + 2138 (clear-stream _test-input-stream) + 2139 (clear-stream $_test-input-buffered-file->buffer) + 2140 (clear-stream _test-output-stream) + 2141 (clear-stream $_test-output-buffered-file->buffer) + 2142 # + 2143 (write _test-input-stream "fn foo {\n") + 2144 (write _test-input-stream " bar 0\n") + 2145 (write _test-input-stream "}\n") + 2146 (write _test-input-stream "sig bar in: (addr int)\n") + 2147 # convert + 2148 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2149 # no errors + 2150 # not bothering checking output + 2151 # . epilogue + 2152 89/<- %esp 5/r32/ebp + 2153 5d/pop-to-ebp + 2154 c3/return + 2155 + 2156 test-convert-function-call-with-signature: + 2157 # . prologue + 2158 55/push-ebp + 2159 89/<- %ebp 4/r32/esp + 2160 # setup + 2161 (clear-stream _test-input-stream) + 2162 (clear-stream $_test-input-buffered-file->buffer) + 2163 (clear-stream _test-output-stream) + 2164 (clear-stream $_test-output-buffered-file->buffer) + 2165 # + 2166 (write _test-input-stream "fn main -> _/ebx: int {\n") + 2167 (write _test-input-stream " var result/eax: int <- do-add 3 4\n") + 2168 (write _test-input-stream " return result\n") + 2169 (write _test-input-stream "}\n") + 2170 (write _test-input-stream "sig do-add a: int, b: int -> _/eax: int\n") + 2171 # convert + 2172 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2173 (flush _test-output-buffered-file) + 2174 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2180 # check output + 2181 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call-with-signature/0") + 2182 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-signature/1") + 2183 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-signature/2") + 2184 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-signature/3") + 2185 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-signature/4") + 2186 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:loop:" "F - test-convert-function-call-with-signature/5") + 2187 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-literal-arg/6") + 2188 (check-next-stream-line-equal _test-output-stream " (do-add 3 4)" "F - test-convert-function-call-with-signature/6") + 2189 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8") + 2190 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-local-var-in-reg/9") + 2191 (check-next-stream-line-equal _test-output-stream " e9/jump $main:0x00000001:break/disp32" "F - test-convert-function-call-with-literal-arg/10") + 2192 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-signature/7") + 2193 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:break:" "F - test-convert-function-call-with-signature/8") + 2194 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-signature/9") + 2195 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-signature/10") + 2196 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-signature/11") + 2197 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-signature/12") + 2198 # . epilogue + 2199 89/<- %esp 5/r32/ebp + 2200 5d/pop-to-ebp + 2201 c3/return + 2202 + 2203 test-convert-function-with-local-var-in-mem: + 2204 # . prologue + 2205 55/push-ebp + 2206 89/<- %ebp 4/r32/esp + 2207 # setup + 2208 (clear-stream _test-input-stream) + 2209 (clear-stream $_test-input-buffered-file->buffer) + 2210 (clear-stream _test-output-stream) + 2211 (clear-stream $_test-output-buffered-file->buffer) + 2212 # + 2213 (write _test-input-stream "fn foo {\n") + 2214 (write _test-input-stream " var x: int\n") + 2215 (write _test-input-stream " increment x\n") + 2216 (write _test-input-stream "}\n") + 2217 # convert + 2218 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2219 (flush _test-output-buffered-file) + 2220 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2226 # check output + 2227 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-mem/0") + 2228 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-mem/1") + 2229 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-mem/2") + 2230 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-mem/3") + 2231 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-mem/4") + 2232 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-mem/5") + 2233 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-mem/6") + 2234 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-mem/7") + 2235 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-mem/8") + 2236 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-mem/9") + 2237 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-mem/10") + 2238 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-mem/11") + 2239 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-mem/12") + 2240 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-mem/13") + 2241 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-mem/14") + 2242 # . epilogue + 2243 89/<- %esp 5/r32/ebp + 2244 5d/pop-to-ebp + 2245 c3/return + 2246 + 2247 test-convert-invalid-literal: + 2248 # . prologue + 2249 55/push-ebp + 2250 89/<- %ebp 4/r32/esp + 2251 # setup + 2252 (clear-stream _test-input-stream) + 2253 (clear-stream $_test-input-buffered-file->buffer) + 2254 (clear-stream _test-output-stream) + 2255 (clear-stream $_test-output-buffered-file->buffer) + 2256 (clear-stream _test-error-stream) + 2257 (clear-stream $_test-error-buffered-file->buffer) + 2258 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2259 68/push 0/imm32 + 2260 68/push 0/imm32 + 2261 89/<- %edx 4/r32/esp + 2262 (tailor-exit-descriptor %edx 0x10) + 2263 # + 2264 (write _test-input-stream "fn foo {\n") + 2265 (write _test-input-stream " increment 1n\n") + 2266 (write _test-input-stream "}\n") + 2267 # convert + 2268 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2269 # registers except esp clobbered at this point + 2270 # restore ed + 2271 89/<- %edx 4/r32/esp + 2272 (flush _test-output-buffered-file) + 2273 (flush _test-error-buffered-file) + 2274 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2280 # check output + 2281 (check-stream-equal _test-output-stream "" "F - test-convert-invalid-literal: output should be empty") + 2282 (check-next-stream-line-equal _test-error-stream "fn foo: variable '1n' cannot begin with a digit (or do you have a typo in a number?)" "F - test-convert-invalid-literal: error message") + 2283 # check that stop(1) was called + 2284 (check-ints-equal *(edx+4) 2 "F - test-convert-invalid-literal: exit status") + 2285 # don't restore from ebp + 2286 81 0/subop/add %esp 8/imm32 + 2287 # . epilogue + 2288 5d/pop-to-ebp + 2289 c3/return + 2290 + 2291 test-local-var-in-mem-has-no-initializer: + 2292 # . prologue + 2293 55/push-ebp + 2294 89/<- %ebp 4/r32/esp + 2295 # setup + 2296 (clear-stream _test-input-stream) + 2297 (clear-stream $_test-input-buffered-file->buffer) + 2298 (clear-stream _test-output-stream) + 2299 (clear-stream $_test-output-buffered-file->buffer) + 2300 (clear-stream _test-error-stream) + 2301 (clear-stream $_test-error-buffered-file->buffer) + 2302 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2303 68/push 0/imm32 + 2304 68/push 0/imm32 + 2305 89/<- %edx 4/r32/esp + 2306 (tailor-exit-descriptor %edx 0x10) + 2307 # + 2308 (write _test-input-stream "fn foo {\n") + 2309 (write _test-input-stream " var x: int <- copy 0\n") + 2310 (write _test-input-stream " increment x\n") + 2311 (write _test-input-stream "}\n") + 2312 # convert + 2313 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2314 # registers except esp clobbered at this point + 2315 # restore ed + 2316 89/<- %edx 4/r32/esp + 2317 (flush _test-output-buffered-file) + 2318 (flush _test-error-buffered-file) + 2319 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2325 # check output + 2326 (check-stream-equal _test-output-stream "" "F - test-var-in-mem-has-no-initializer: output should be empty") + 2327 (check-next-stream-line-equal _test-error-stream "fn foo: var x: variables on the stack can't take an initializer" "F - test-var-in-mem-has-no-initializer: error message") + 2328 # check that stop(1) was called + 2329 (check-ints-equal *(edx+4) 2 "F - test-var-in-mem-has-no-initializer: exit status") + 2330 # don't restore from ebp + 2331 81 0/subop/add %esp 8/imm32 + 2332 # . epilogue + 2333 5d/pop-to-ebp + 2334 c3/return + 2335 + 2336 test-convert-function-with-local-var-with-compound-type-in-mem: + 2337 # . prologue + 2338 55/push-ebp + 2339 89/<- %ebp 4/r32/esp + 2340 # setup + 2341 (clear-stream _test-input-stream) + 2342 (clear-stream $_test-input-buffered-file->buffer) + 2343 (clear-stream _test-output-stream) + 2344 (clear-stream $_test-output-buffered-file->buffer) + 2345 # + 2346 (write _test-input-stream "fn foo {\n") + 2347 (write _test-input-stream " var x: (addr int)\n") + 2348 (write _test-input-stream " copy-to x, 0\n") + 2349 (write _test-input-stream "}\n") + 2350 # convert + 2351 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2352 (flush _test-output-buffered-file) + 2353 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2359 # check output + 2360 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/0") + 2361 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-compound-type-in-mem/1") + 2362 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/2") + 2363 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/3") + 2364 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-compound-type-in-mem/4") + 2365 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/5") + 2366 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-compound-type-in-mem/6") + 2367 (check-next-stream-line-equal _test-output-stream " c7 0/subop/copy *(ebp+0xfffffffc) 0/imm32" "F - test-convert-function-with-local-var-with-compound-type-in-mem/7") + 2368 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-with-compound-type-in-mem/8") + 2369 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-compound-type-in-mem/9") + 2370 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-compound-type-in-mem/10") + 2371 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-compound-type-in-mem/11") + 2372 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/12") + 2373 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-compound-type-in-mem/13") + 2374 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-compound-type-in-mem/14") + 2375 # . epilogue + 2376 89/<- %esp 5/r32/ebp + 2377 5d/pop-to-ebp + 2378 c3/return + 2379 + 2380 test-convert-function-with-local-var-in-reg: + 2381 # . prologue + 2382 55/push-ebp + 2383 89/<- %ebp 4/r32/esp + 2384 # setup + 2385 (clear-stream _test-input-stream) + 2386 (clear-stream $_test-input-buffered-file->buffer) + 2387 (clear-stream _test-output-stream) + 2388 (clear-stream $_test-output-buffered-file->buffer) + 2389 # + 2390 (write _test-input-stream "fn foo {\n") + 2391 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 2392 (write _test-input-stream " x <- increment\n") + 2393 (write _test-input-stream "}\n") + 2394 # convert + 2395 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2396 (flush _test-output-buffered-file) + 2397 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2403 # check output + 2404 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-reg/0") + 2405 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-reg/1") + 2406 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-reg/2") + 2407 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-reg/3") + 2408 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-reg/4") + 2409 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-reg/5") + 2410 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-local-var-in-reg/6") + 2411 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-function-with-local-var-in-reg/7") + 2412 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-convert-function-with-local-var-in-reg/8") + 2413 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-local-var-in-reg/9") + 2414 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-reg/10") + 2415 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-reg/11") + 2416 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-reg/12") + 2417 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-reg/13") + 2418 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-reg/14") + 2419 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-reg/15") + 2420 # . epilogue + 2421 89/<- %esp 5/r32/ebp + 2422 5d/pop-to-ebp + 2423 c3/return + 2424 + 2425 test-float-var-in-wrong-register: + 2426 # . prologue + 2427 55/push-ebp + 2428 89/<- %ebp 4/r32/esp + 2429 # setup + 2430 (clear-stream _test-input-stream) + 2431 (clear-stream $_test-input-buffered-file->buffer) + 2432 (clear-stream _test-output-stream) + 2433 (clear-stream $_test-output-buffered-file->buffer) + 2434 (clear-stream _test-error-stream) + 2435 (clear-stream $_test-error-buffered-file->buffer) + 2436 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2437 68/push 0/imm32 + 2438 68/push 0/imm32 + 2439 89/<- %edx 4/r32/esp + 2440 (tailor-exit-descriptor %edx 0x10) + 2441 # + 2442 (write _test-input-stream "fn foo {\n") + 2443 (write _test-input-stream " var x/eax: int <- copy 0\n") + 2444 (write _test-input-stream " var y/eax: float <- convert x\n") + 2445 (write _test-input-stream "}\n") + 2446 # convert + 2447 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2448 # registers except esp clobbered at this point + 2449 # restore ed + 2450 89/<- %edx 4/r32/esp + 2451 (flush _test-output-buffered-file) + 2452 (flush _test-error-buffered-file) + 2453 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2459 # check output + 2460 (check-stream-equal _test-output-stream "" "F - test-float-var-in-wrong-register: output should be empty") + 2461 (check-next-stream-line-equal _test-error-stream "fn foo: float var 'y' should be in a floating-point register" "F - test-float-var-in-wrong-register: error message") + 2462 # check that stop(1) was called + 2463 (check-ints-equal *(edx+4) 2 "F - test-float-var-in-wrong-register: exit status") + 2464 # don't restore from ebp + 2465 81 0/subop/add %esp 8/imm32 + 2466 # . epilogue + 2467 5d/pop-to-ebp + 2468 c3/return + 2469 + 2470 test-non-float-var-in-wrong-register: + 2471 # . prologue + 2472 55/push-ebp + 2473 89/<- %ebp 4/r32/esp + 2474 # setup + 2475 (clear-stream _test-input-stream) + 2476 (clear-stream $_test-input-buffered-file->buffer) + 2477 (clear-stream _test-output-stream) + 2478 (clear-stream $_test-output-buffered-file->buffer) + 2479 (clear-stream _test-error-stream) + 2480 (clear-stream $_test-error-buffered-file->buffer) + 2481 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2482 68/push 0/imm32 + 2483 68/push 0/imm32 + 2484 89/<- %edx 4/r32/esp + 2485 (tailor-exit-descriptor %edx 0x10) + 2486 # + 2487 (write _test-input-stream "fn foo {\n") + 2488 (write _test-input-stream " var x/xmm5: int <- copy 0\n") + 2489 (write _test-input-stream "}\n") + 2490 # convert + 2491 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2492 # registers except esp clobbered at this point + 2493 # restore ed + 2494 89/<- %edx 4/r32/esp + 2495 (flush _test-output-buffered-file) + 2496 (flush _test-error-buffered-file) + 2497 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2503 # check output + 2504 (check-stream-equal _test-output-stream "" "F - test-non-float-var-in-wrong-register: output should be empty") + 2505 (check-next-stream-line-equal _test-error-stream "fn foo: non-float var 'x' should be in an integer register" "F - test-non-float-var-in-wrong-register: error message") + 2506 # check that stop(1) was called + 2507 (check-ints-equal *(edx+4) 2 "F - test-non-float-var-in-wrong-register: exit status") + 2508 # don't restore from ebp + 2509 81 0/subop/add %esp 8/imm32 + 2510 # . epilogue + 2511 5d/pop-to-ebp + 2512 c3/return + 2513 + 2514 test-convert-function-with-allocate: + 2515 # . prologue + 2516 55/push-ebp + 2517 89/<- %ebp 4/r32/esp + 2518 # setup + 2519 (clear-stream _test-input-stream) + 2520 (clear-stream $_test-input-buffered-file->buffer) + 2521 (clear-stream _test-output-stream) + 2522 (clear-stream $_test-output-buffered-file->buffer) + 2523 # + 2524 (write _test-input-stream "fn foo {\n") + 2525 (write _test-input-stream " var x/ecx: (addr handle int) <- copy 0\n") + 2526 (write _test-input-stream " allocate x\n") + 2527 (write _test-input-stream "}\n") + 2528 # convert + 2529 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2530 (flush _test-output-buffered-file) + 2531 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2537 # check output + 2538 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-allocate/0") + 2539 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-allocate/1") + 2540 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-allocate/2") + 2541 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-allocate/3") + 2542 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-allocate/4") + 2543 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-allocate/5") + 2544 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-allocate/6") + 2545 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-allocate/7") + 2546 (check-next-stream-line-equal _test-output-stream " (allocate Heap 0x00000004 %ecx)" "F - test-convert-function-with-allocate/8") # 4 = size-of(int) + 2547 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-allocate/9") + 2548 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-allocate/10") + 2549 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-allocate/11") + 2550 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-allocate/12") + 2551 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-allocate/13") + 2552 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-allocate/14") + 2553 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-allocate/15") + 2554 # . epilogue + 2555 89/<- %esp 5/r32/ebp + 2556 5d/pop-to-ebp + 2557 c3/return + 2558 + 2559 test-initializer-in-hex: + 2560 # . prologue + 2561 55/push-ebp + 2562 89/<- %ebp 4/r32/esp + 2563 # setup + 2564 (clear-stream _test-input-stream) + 2565 (clear-stream $_test-input-buffered-file->buffer) + 2566 (clear-stream _test-output-stream) + 2567 (clear-stream $_test-output-buffered-file->buffer) + 2568 (clear-stream _test-error-stream) + 2569 (clear-stream $_test-error-buffered-file->buffer) + 2570 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2571 68/push 0/imm32 + 2572 68/push 0/imm32 + 2573 89/<- %edx 4/r32/esp + 2574 (tailor-exit-descriptor %edx 0x10) + 2575 # + 2576 (write _test-input-stream "fn foo {\n") + 2577 (write _test-input-stream " var x/ecx: int <- copy 10\n") + 2578 (write _test-input-stream "}\n") + 2579 # convert + 2580 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2581 # registers except esp clobbered at this point + 2582 # restore ed + 2583 89/<- %edx 4/r32/esp + 2584 (flush _test-output-buffered-file) + 2585 (flush _test-error-buffered-file) + 2586 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2592 # check output + 2593 (check-stream-equal _test-output-stream "" "F - test-initializer-in-hex: output should be empty") + 2594 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; start '10' with a '0x' to be unambiguous, converting it to hexadecimal as necessary." "F - test-initializer-in-hex: error message") + 2595 # check that stop(1) was called + 2596 (check-ints-equal *(edx+4) 2 "F - test-initializer-in-hex: exit status") + 2597 # don't restore from ebp + 2598 81 0/subop/add %esp 8/imm32 + 2599 # . epilogue + 2600 5d/pop-to-ebp + 2601 c3/return + 2602 + 2603 test-convert-function-with-second-local-var-in-same-reg: + 2604 # . prologue + 2605 55/push-ebp + 2606 89/<- %ebp 4/r32/esp + 2607 # setup + 2608 (clear-stream _test-input-stream) + 2609 (clear-stream $_test-input-buffered-file->buffer) + 2610 (clear-stream _test-output-stream) + 2611 (clear-stream $_test-output-buffered-file->buffer) + 2612 # + 2613 (write _test-input-stream "fn foo {\n") + 2614 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 2615 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 2616 (write _test-input-stream " y <- increment\n") + 2617 (write _test-input-stream "}\n") + 2618 # convert + 2619 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2620 (flush _test-output-buffered-file) + 2621 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2627 # check output + 2628 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-second-local-var-in-same-reg/0") + 2629 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-second-local-var-in-same-reg/1") + 2630 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-second-local-var-in-same-reg/2") + 2631 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-second-local-var-in-same-reg/3") + 2632 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-second-local-var-in-same-reg/4") + 2633 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-second-local-var-in-same-reg/5") + 2634 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-second-local-var-in-same-reg/6") + 2635 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-function-with-second-local-var-in-same-reg/7") + 2636 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-convert-function-with-second-local-var-in-same-reg/8") + 2637 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-convert-function-with-second-local-var-in-same-reg/9") + 2638 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-second-local-var-in-same-reg/10") + 2639 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-second-local-var-in-same-reg/11") + 2640 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-second-local-var-in-same-reg/12") + 2641 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-second-local-var-in-same-reg/13") + 2642 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-second-local-var-in-same-reg/14") + 2643 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-second-local-var-in-same-reg/15") + 2644 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-second-local-var-in-same-reg/16") + 2645 # . epilogue + 2646 89/<- %esp 5/r32/ebp + 2647 5d/pop-to-ebp + 2648 c3/return + 2649 + 2650 test-read-clobbered-reg-var: + 2651 # . prologue + 2652 55/push-ebp + 2653 89/<- %ebp 4/r32/esp + 2654 # setup + 2655 (clear-stream _test-input-stream) + 2656 (clear-stream $_test-input-buffered-file->buffer) + 2657 (clear-stream _test-output-stream) + 2658 (clear-stream $_test-output-buffered-file->buffer) + 2659 (clear-stream _test-error-stream) + 2660 (clear-stream $_test-error-buffered-file->buffer) + 2661 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) # bytes of args in call to convert-mu + 2662 68/push 0/imm32 + 2663 68/push 0/imm32 + 2664 89/<- %edx 4/r32/esp + 2665 (tailor-exit-descriptor %edx 0x10) + 2666 # + 2667 (write _test-input-stream "fn foo {\n") + 2668 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 2669 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 2670 (write _test-input-stream " x <- increment\n") + 2671 (write _test-input-stream "}\n") + 2672 # convert + 2673 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2674 # registers except esp clobbered at this point + 2675 # restore ed + 2676 89/<- %edx 4/r32/esp + 2677 (flush _test-output-buffered-file) + 2678 (flush _test-error-buffered-file) + 2679 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2685 # check output + 2686 (check-stream-equal _test-output-stream "" "F - test-read-clobbered-reg-var: output should be empty") + 2687 (check-next-stream-line-equal _test-error-stream "fn foo: register ecx reads var 'x' after writing var 'y'" "F - test-read-clobbered-reg-var: error message") + 2688 # check that stop(1) was called + 2689 (check-ints-equal *(edx+4) 2 "F - test-read-clobbered-reg-var: exit status") + 2690 # don't restore from ebp + 2691 81 0/subop/add %esp 8/imm32 + 2692 # . epilogue + 2693 5d/pop-to-ebp + 2694 c3/return + 2695 + 2696 test-overlapping-int-fp-registers: + 2697 # . prologue + 2698 55/push-ebp + 2699 89/<- %ebp 4/r32/esp + 2700 # setup + 2701 (clear-stream _test-input-stream) + 2702 (clear-stream $_test-input-buffered-file->buffer) + 2703 (clear-stream _test-output-stream) + 2704 (clear-stream $_test-output-buffered-file->buffer) + 2705 (clear-stream _test-error-stream) + 2706 (clear-stream $_test-error-buffered-file->buffer) + 2707 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) # bytes of args in call to convert-mu + 2708 68/push 0/imm32 + 2709 68/push 0/imm32 + 2710 89/<- %edx 4/r32/esp + 2711 (tailor-exit-descriptor %edx 0x10) + 2712 # + 2713 (write _test-input-stream "fn foo {\n") + 2714 (write _test-input-stream " var x/eax: int <- copy 3\n") + 2715 (write _test-input-stream " var y/xmm0: float <- convert x\n") + 2716 (write _test-input-stream " x <- increment\n") + 2717 (write _test-input-stream "}\n") + 2718 # convert + 2719 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2720 # registers except esp clobbered at this point + 2721 # restore ed + 2722 89/<- %edx 4/r32/esp + 2723 (flush _test-output-buffered-file) + 2724 (flush _test-error-buffered-file) + 2725 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2731 # no errors + 2732 (check-next-stream-line-equal _test-error-stream "" "F - test-overlapping-int-fp-registers: error message") + 2733 # don't bother checking the generated code + 2734 # don't restore from ebp + 2735 81 0/subop/add %esp 8/imm32 + 2736 # . epilogue + 2737 5d/pop-to-ebp + 2738 c3/return + 2739 + 2740 test-convert-function-call: + 2741 # . prologue + 2742 55/push-ebp + 2743 89/<- %ebp 4/r32/esp + 2744 # setup + 2745 (clear-stream _test-input-stream) + 2746 (clear-stream $_test-input-buffered-file->buffer) + 2747 (clear-stream _test-output-stream) + 2748 (clear-stream $_test-output-buffered-file->buffer) + 2749 # + 2750 (write _test-input-stream "fn main -> _/ebx: int {\n") + 2751 (write _test-input-stream " var result/ebx: int <- foo\n") + 2752 (write _test-input-stream " return result\n") + 2753 (write _test-input-stream "}\n") + 2754 (write _test-input-stream "fn foo -> _/ebx: int {\n") + 2755 (write _test-input-stream " var result/ebx: int <- copy 3\n") + 2756 (write _test-input-stream " return result\n") + 2757 (write _test-input-stream "}\n") + 2758 # convert + 2759 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2760 (flush _test-output-buffered-file) + 2761 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2767 # check output + 2768 (check-next-stream-line-equal _test-output-stream "main:" "F - test-convert-function-call/0") + 2769 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call/1") + 2770 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call/2") + 2771 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call/3") + 2772 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call/4") + 2773 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:loop:" "F - test-convert-function-call/5") + 2774 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-function-call-with-literal-arg/6") + 2775 (check-next-stream-line-equal _test-output-stream " (foo)" "F - test-convert-function-call/6") + 2776 (check-next-stream-line-equal _test-output-stream " 8b/-> %ebx 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8") + 2777 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-call-with-literal-arg/27") + 2778 (check-next-stream-line-equal _test-output-stream " e9/jump $main:0x00000001:break/disp32" "F - test-convert-function-call-with-literal-arg/10") + 2779 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call/7") + 2780 (check-next-stream-line-equal _test-output-stream "$main:0x00000001:break:" "F - test-convert-function-call/8") + 2781 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call/9") + 2782 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call/10") + 2783 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call/11") + 2784 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call/12") + 2785 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call/13") + 2786 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call/14") + 2787 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call/15") + 2788 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call/16") + 2789 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call/17") + 2790 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-call/18") + 2791 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-function-call-with-literal-arg/6") + 2792 (check-next-stream-line-equal _test-output-stream " bb/copy-to-ebx 3/imm32" "F - test-convert-function-call/19") + 2793 (check-next-stream-line-equal _test-output-stream " 8b/-> %ebx 0x00000003/r32" "F - test-convert-function-call-with-literal-arg/8") + 2794 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-call-with-literal-arg/27") + 2795 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-call-with-literal-arg/10") + 2796 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call/20") + 2797 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-call/21") + 2798 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call/22") + 2799 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call/23") + 2800 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call/24") + 2801 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call/25") + 2802 # . epilogue + 2803 89/<- %esp 5/r32/ebp + 2804 5d/pop-to-ebp + 2805 c3/return + 2806 + 2807 test-convert-function-call-with-inout-with-compound-type: + 2808 # . prologue + 2809 55/push-ebp + 2810 89/<- %ebp 4/r32/esp + 2811 # setup + 2812 (clear-stream _test-input-stream) + 2813 (clear-stream $_test-input-buffered-file->buffer) + 2814 (clear-stream _test-output-stream) + 2815 (clear-stream $_test-output-buffered-file->buffer) + 2816 # + 2817 (write _test-input-stream "fn f {\n") + 2818 (write _test-input-stream " var x: (addr int)\n") + 2819 (write _test-input-stream " g x\n") + 2820 (write _test-input-stream "}\n") + 2821 (write _test-input-stream "fn g a: (addr int) {\n") + 2822 (write _test-input-stream "}\n") + 2823 # convert + 2824 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 2825 (flush _test-output-buffered-file) + 2826 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2832 # check output + 2833 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-inout-with-compound-type/0") + 2834 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-inout-with-compound-type/1") + 2835 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-inout-with-compound-type/2") + 2836 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-inout-with-compound-type/3") + 2837 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-inout-with-compound-type/4") + 2838 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-inout-with-compound-type/5") + 2839 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-inout-with-compound-type/6") + 2840 (check-next-stream-line-equal _test-output-stream " (g *(ebp+0xfffffffc))" "F - test-convert-function-call-with-inout-with-compound-type/7") + 2841 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-call-with-inout-with-compound-type/8") + 2842 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-inout-with-compound-type/9") + 2843 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-inout-with-compound-type/10") + 2844 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-inout-with-compound-type/11") + 2845 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-inout-with-compound-type/12") + 2846 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-inout-with-compound-type/13") + 2847 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-inout-with-compound-type/14") + 2848 (check-next-stream-line-equal _test-output-stream "g:" "F - test-convert-function-call-with-inout-with-compound-type/15") + 2849 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-inout-with-compound-type/16") + 2850 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-inout-with-compound-type/17") + 2851 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-inout-with-compound-type/18") + 2852 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-inout-with-compound-type/19") + 2853 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-inout-with-compound-type/20") + 2854 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-inout-with-compound-type/21") + 2855 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-inout-with-compound-type/22") + 2856 # . epilogue + 2857 89/<- %esp 5/r32/ebp + 2858 5d/pop-to-ebp + 2859 c3/return + 2860 + 2861 test-convert-function-call-with-inout-with-type-parameter: + 2862 # . prologue + 2863 55/push-ebp + 2864 89/<- %ebp 4/r32/esp + 2865 # setup + 2866 (clear-stream _test-input-stream) + 2867 (clear-stream $_test-input-buffered-file->buffer) + 2868 (clear-stream _test-output-stream) + 2869 (clear-stream $_test-output-buffered-file->buffer) + 2870 (clear-stream _test-error-stream) + 2871 (clear-stream $_test-error-buffered-file->buffer) + 2872 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2873 68/push 0/imm32 + 2874 68/push 0/imm32 + 2875 89/<- %edx 4/r32/esp + 2876 (tailor-exit-descriptor %edx 0x10) + 2877 # + 2878 (write _test-input-stream "fn f {\n") + 2879 (write _test-input-stream " var x: (addr int)\n") + 2880 (write _test-input-stream " g x\n") + 2881 (write _test-input-stream "}\n") + 2882 (write _test-input-stream "fn g a: (addr _) {\n") + 2883 (write _test-input-stream "}\n") + 2884 # convert + 2885 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2886 # registers except esp clobbered at this point + 2887 # restore ed + 2888 89/<- %edx 4/r32/esp + 2889 (flush _test-output-buffered-file) + 2890 (flush _test-error-buffered-file) + 2891 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2897 # no error; types matched + 2898 (check-stream-equal _test-error-stream "" "F - test-convert-function-call-with-inout-with-type-parameter: error stream should be empty") + 2899 # don't bother checking the generated code; that's in the test 'test-local-clobbered-by-fn-output' below + 2900 # don't restore from ebp + 2901 81 0/subop/add %esp 8/imm32 + 2902 # . epilogue + 2903 5d/pop-to-ebp + 2904 c3/return + 2905 + 2906 test-convert-function-call-with-incorrect-inout-type: + 2907 # . prologue + 2908 55/push-ebp + 2909 89/<- %ebp 4/r32/esp + 2910 # setup + 2911 (clear-stream _test-input-stream) + 2912 (clear-stream $_test-input-buffered-file->buffer) + 2913 (clear-stream _test-output-stream) + 2914 (clear-stream $_test-output-buffered-file->buffer) + 2915 (clear-stream _test-error-stream) + 2916 (clear-stream $_test-error-buffered-file->buffer) + 2917 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2918 68/push 0/imm32 + 2919 68/push 0/imm32 + 2920 89/<- %edx 4/r32/esp + 2921 (tailor-exit-descriptor %edx 0x10) + 2922 # + 2923 (write _test-input-stream "fn f {\n") + 2924 (write _test-input-stream " var x: int\n") + 2925 (write _test-input-stream " g x\n") + 2926 (write _test-input-stream "}\n") + 2927 (write _test-input-stream "fn g a: foo {\n") + 2928 (write _test-input-stream "}\n") + 2929 # convert + 2930 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2931 # registers except esp clobbered at this point + 2932 # restore ed + 2933 89/<- %edx 4/r32/esp + 2934 (flush _test-output-buffered-file) + 2935 (flush _test-error-buffered-file) + 2936 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2942 # check output + 2943 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-inout-type: output should be empty") + 2944 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'x' is not right" "F - test-convert-function-call-with-incorrect-inout-type: error message") + 2945 # check that stop(1) was called + 2946 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-inout-type: exit status") + 2947 # don't restore from ebp + 2948 81 0/subop/add %esp 8/imm32 + 2949 5d/pop-to-ebp + 2950 c3/return + 2951 + 2952 test-convert-function-call-with-inout-with-incorrect-compound-type: + 2953 # . prologue + 2954 55/push-ebp + 2955 89/<- %ebp 4/r32/esp + 2956 # setup + 2957 (clear-stream _test-input-stream) + 2958 (clear-stream $_test-input-buffered-file->buffer) + 2959 (clear-stream _test-output-stream) + 2960 (clear-stream $_test-output-buffered-file->buffer) + 2961 (clear-stream _test-error-stream) + 2962 (clear-stream $_test-error-buffered-file->buffer) + 2963 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 2964 68/push 0/imm32 + 2965 68/push 0/imm32 + 2966 89/<- %edx 4/r32/esp + 2967 (tailor-exit-descriptor %edx 0x10) + 2968 # + 2969 (write _test-input-stream "fn f {\n") + 2970 (write _test-input-stream " var x: (addr int)\n") + 2971 (write _test-input-stream " g x\n") + 2972 (write _test-input-stream "}\n") + 2973 (write _test-input-stream "fn g a: (addr bool) {\n") + 2974 (write _test-input-stream "}\n") + 2975 # convert + 2976 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 2977 # registers except esp clobbered at this point + 2978 # restore ed + 2979 89/<- %edx 4/r32/esp + 2980 (flush _test-output-buffered-file) + 2981 (flush _test-error-buffered-file) + 2982 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 2988 # check output + 2989 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incorrect-compound-type: output should be empty") + 2990 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'x' is not right" "F - test-convert-function-call-with-inout-with-incorrect-compound-type: error message") + 2991 # don't restore from ebp + 2992 81 0/subop/add %esp 8/imm32 + 2993 # . epilogue + 2994 5d/pop-to-ebp + 2995 c3/return + 2996 + 2997 test-convert-function-call-with-inout-with-multiple-type-parameters: + 2998 # . prologue + 2999 55/push-ebp + 3000 89/<- %ebp 4/r32/esp + 3001 # setup + 3002 (clear-stream _test-input-stream) + 3003 (clear-stream $_test-input-buffered-file->buffer) + 3004 (clear-stream _test-output-stream) + 3005 (clear-stream $_test-output-buffered-file->buffer) + 3006 (clear-stream _test-error-stream) + 3007 (clear-stream $_test-error-buffered-file->buffer) + 3008 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3009 68/push 0/imm32 + 3010 68/push 0/imm32 + 3011 89/<- %edx 4/r32/esp + 3012 (tailor-exit-descriptor %edx 0x10) + 3013 # + 3014 (write _test-input-stream "fn f {\n") + 3015 (write _test-input-stream " var x: (addr int)\n") + 3016 (write _test-input-stream " var y: (addr int)\n") + 3017 (write _test-input-stream " g x, y\n") + 3018 (write _test-input-stream "}\n") + 3019 (write _test-input-stream "fn g a: (addr _), b: (addr _) {\n") + 3020 (write _test-input-stream "}\n") + 3021 # convert + 3022 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3023 # registers except esp clobbered at this point + 3024 # restore ed + 3025 89/<- %edx 4/r32/esp + 3026 (flush _test-output-buffered-file) + 3027 (flush _test-error-buffered-file) + 3028 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3034 # no errors + 3035 (check-stream-equal _test-error-stream "" "F - test-convert-function-call-with-inout-with-multiple-type-parameters: error stream should be empty") + 3036 # don't bother checking the generated code + 3037 # don't restore from ebp + 3038 81 0/subop/add %esp 8/imm32 + 3039 # . epilogue + 3040 5d/pop-to-ebp + 3041 c3/return + 3042 + 3043 test-type-parameter-matches-rest-of-type: + 3044 # . prologue + 3045 55/push-ebp + 3046 89/<- %ebp 4/r32/esp + 3047 # setup + 3048 (clear-stream _test-input-stream) + 3049 (clear-stream $_test-input-buffered-file->buffer) + 3050 (clear-stream _test-output-stream) + 3051 (clear-stream $_test-output-buffered-file->buffer) + 3052 (clear-stream _test-error-stream) + 3053 (clear-stream $_test-error-buffered-file->buffer) + 3054 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3055 68/push 0/imm32 + 3056 68/push 0/imm32 + 3057 89/<- %edx 4/r32/esp + 3058 (tailor-exit-descriptor %edx 0x10) + 3059 # + 3060 (write _test-input-stream "fn f {\n") + 3061 (write _test-input-stream " var x: (addr array int)\n") + 3062 (write _test-input-stream " g x\n") + 3063 (write _test-input-stream "}\n") + 3064 (write _test-input-stream "fn g a: (addr _) {\n") + 3065 (write _test-input-stream "}\n") + 3066 # convert + 3067 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3068 # registers except esp clobbered at this point + 3069 # restore ed + 3070 89/<- %edx 4/r32/esp + 3071 (flush _test-output-buffered-file) + 3072 (flush _test-error-buffered-file) + 3073 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3079 # no errors + 3080 (check-stream-equal _test-error-stream "" "F - test-type-parameter-matches-rest-of-type: error stream should be empty") + 3081 # don't bother checking the generated code + 3082 # don't restore from ebp + 3083 81 0/subop/add %esp 8/imm32 + 3084 # . epilogue + 3085 5d/pop-to-ebp + 3086 c3/return + 3087 + 3088 test-convert-function-call-with-inout-with-incompatible-type-parameters: + 3089 # . prologue + 3090 55/push-ebp + 3091 89/<- %ebp 4/r32/esp + 3092 # setup + 3093 (clear-stream _test-input-stream) + 3094 (clear-stream $_test-input-buffered-file->buffer) + 3095 (clear-stream _test-output-stream) + 3096 (clear-stream $_test-output-buffered-file->buffer) + 3097 (clear-stream _test-error-stream) + 3098 (clear-stream $_test-error-buffered-file->buffer) + 3099 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3100 68/push 0/imm32 + 3101 68/push 0/imm32 + 3102 89/<- %edx 4/r32/esp + 3103 (tailor-exit-descriptor %edx 0x10) + 3104 # + 3105 (write _test-input-stream "fn f {\n") + 3106 (write _test-input-stream " var x: (addr int)\n") + 3107 (write _test-input-stream " var y: (addr boolean)\n") + 3108 (write _test-input-stream " g x, y\n") + 3109 (write _test-input-stream "}\n") + 3110 (write _test-input-stream "fn g a: (addr _T), b: (addr _T) {\n") + 3111 (write _test-input-stream "}\n") + 3112 # convert + 3113 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3114 # registers except esp clobbered at this point + 3115 # restore ed + 3116 89/<- %edx 4/r32/esp + 3117 (flush _test-output-buffered-file) + 3118 (flush _test-error-buffered-file) + 3119 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3125 # check output + 3126 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: output should be empty") + 3127 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for inout 'y' is not right" "F - test-convert-function-call-with-inout-with-incompatible-type-parameters: error message") + 3128 # don't restore from ebp + 3129 81 0/subop/add %esp 8/imm32 + 3130 # . epilogue + 3131 5d/pop-to-ebp + 3132 c3/return + 3133 + 3134 test-convert-function-call-with-too-few-inouts: + 3135 # . prologue + 3136 55/push-ebp + 3137 89/<- %ebp 4/r32/esp + 3138 # setup + 3139 (clear-stream _test-input-stream) + 3140 (clear-stream $_test-input-buffered-file->buffer) + 3141 (clear-stream _test-output-stream) + 3142 (clear-stream $_test-output-buffered-file->buffer) + 3143 (clear-stream _test-error-stream) + 3144 (clear-stream $_test-error-buffered-file->buffer) + 3145 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3146 68/push 0/imm32 + 3147 68/push 0/imm32 + 3148 89/<- %edx 4/r32/esp + 3149 (tailor-exit-descriptor %edx 0x10) + 3150 # + 3151 (write _test-input-stream "fn f {\n") + 3152 (write _test-input-stream " g\n") + 3153 (write _test-input-stream "}\n") + 3154 (write _test-input-stream "fn g a: int {\n") + 3155 (write _test-input-stream "}\n") + 3156 # convert + 3157 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3158 # registers except esp clobbered at this point + 3159 # restore ed + 3160 89/<- %edx 4/r32/esp + 3161 (flush _test-output-buffered-file) + 3162 (flush _test-error-buffered-file) + 3163 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3169 # check output + 3170 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-inouts: output should be empty") + 3171 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few inouts" "F - test-convert-function-call-with-too-few-inouts: error message") + 3172 # check that stop(1) was called + 3173 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-inouts: exit status") + 3174 # don't restore from ebp + 3175 81 0/subop/add %esp 8/imm32 + 3176 5d/pop-to-ebp + 3177 c3/return + 3178 + 3179 test-convert-function-call-with-too-many-inouts: + 3180 # . prologue + 3181 55/push-ebp + 3182 89/<- %ebp 4/r32/esp + 3183 # setup + 3184 (clear-stream _test-input-stream) + 3185 (clear-stream $_test-input-buffered-file->buffer) + 3186 (clear-stream _test-output-stream) + 3187 (clear-stream $_test-output-buffered-file->buffer) + 3188 (clear-stream _test-error-stream) + 3189 (clear-stream $_test-error-buffered-file->buffer) + 3190 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3191 68/push 0/imm32 + 3192 68/push 0/imm32 + 3193 89/<- %edx 4/r32/esp + 3194 (tailor-exit-descriptor %edx 0x10) + 3195 # + 3196 (write _test-input-stream "fn f {\n") + 3197 (write _test-input-stream " var x: int\n") + 3198 (write _test-input-stream " g x\n") + 3199 (write _test-input-stream "}\n") + 3200 (write _test-input-stream "fn g {\n") + 3201 (write _test-input-stream "}\n") + 3202 # convert + 3203 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3204 # registers except esp clobbered at this point + 3205 # restore ed + 3206 89/<- %edx 4/r32/esp + 3207 (flush _test-output-buffered-file) + 3208 (flush _test-error-buffered-file) + 3209 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3215 # check output + 3216 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-inouts: output should be empty") + 3217 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many inouts" "F - test-convert-function-call-with-too-many-inouts: error message") + 3218 # check that stop(1) was called + 3219 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-inouts: exit status") + 3220 # don't restore from ebp + 3221 81 0/subop/add %esp 8/imm32 + 3222 5d/pop-to-ebp + 3223 c3/return + 3224 + 3225 test-convert-function-call-with-incorrect-output-type: + 3226 # . prologue + 3227 55/push-ebp + 3228 89/<- %ebp 4/r32/esp + 3229 # setup + 3230 (clear-stream _test-input-stream) + 3231 (clear-stream $_test-input-buffered-file->buffer) + 3232 (clear-stream _test-output-stream) + 3233 (clear-stream $_test-output-buffered-file->buffer) + 3234 (clear-stream _test-error-stream) + 3235 (clear-stream $_test-error-buffered-file->buffer) + 3236 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3237 68/push 0/imm32 + 3238 68/push 0/imm32 + 3239 89/<- %edx 4/r32/esp + 3240 (tailor-exit-descriptor %edx 0x10) + 3241 # + 3242 (write _test-input-stream "fn f {\n") + 3243 (write _test-input-stream " var x/eax: int <- g\n") + 3244 (write _test-input-stream "}\n") + 3245 (write _test-input-stream "fn g -> _/eax: foo {\n") + 3246 (write _test-input-stream "}\n") + 3247 # convert + 3248 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3249 # registers except esp clobbered at this point + 3250 # restore ed + 3251 89/<- %edx 4/r32/esp + 3252 (flush _test-output-buffered-file) + 3253 (flush _test-error-buffered-file) + 3254 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3260 # check output + 3261 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-type: output should be empty") + 3262 (check-next-stream-line-equal _test-error-stream "fn f: call g: type for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-type: error message") + 3263 # check that stop(1) was called + 3264 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-type: exit status") + 3265 # don't restore from ebp + 3266 81 0/subop/add %esp 8/imm32 + 3267 5d/pop-to-ebp + 3268 c3/return + 3269 + 3270 test-convert-function-call-with-too-few-outputs: + 3271 # . prologue + 3272 55/push-ebp + 3273 89/<- %ebp 4/r32/esp + 3274 # setup + 3275 (clear-stream _test-input-stream) + 3276 (clear-stream $_test-input-buffered-file->buffer) + 3277 (clear-stream _test-output-stream) + 3278 (clear-stream $_test-output-buffered-file->buffer) + 3279 (clear-stream _test-error-stream) + 3280 (clear-stream $_test-error-buffered-file->buffer) + 3281 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3282 68/push 0/imm32 + 3283 68/push 0/imm32 + 3284 89/<- %edx 4/r32/esp + 3285 (tailor-exit-descriptor %edx 0x10) + 3286 # + 3287 (write _test-input-stream "fn f {\n") + 3288 (write _test-input-stream " g\n") + 3289 (write _test-input-stream "}\n") + 3290 (write _test-input-stream "fn g -> _/eax: int {\n") + 3291 (write _test-input-stream "}\n") + 3292 # convert + 3293 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3294 # registers except esp clobbered at this point + 3295 # restore ed + 3296 89/<- %edx 4/r32/esp + 3297 (flush _test-output-buffered-file) + 3298 (flush _test-error-buffered-file) + 3299 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3305 # check output + 3306 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-few-outputs: output should be empty") + 3307 (check-next-stream-line-equal _test-error-stream "fn f: call g: too few outputs" "F - test-convert-function-call-with-too-few-outputs: error message") + 3308 # check that stop(1) was called + 3309 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-few-outputs: exit status") + 3310 # don't restore from ebp + 3311 81 0/subop/add %esp 8/imm32 + 3312 5d/pop-to-ebp + 3313 c3/return + 3314 + 3315 test-convert-function-call-with-too-many-outputs: + 3316 # . prologue + 3317 55/push-ebp + 3318 89/<- %ebp 4/r32/esp + 3319 # setup + 3320 (clear-stream _test-input-stream) + 3321 (clear-stream $_test-input-buffered-file->buffer) + 3322 (clear-stream _test-output-stream) + 3323 (clear-stream $_test-output-buffered-file->buffer) + 3324 (clear-stream _test-error-stream) + 3325 (clear-stream $_test-error-buffered-file->buffer) + 3326 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3327 68/push 0/imm32 + 3328 68/push 0/imm32 + 3329 89/<- %edx 4/r32/esp + 3330 (tailor-exit-descriptor %edx 0x10) + 3331 # + 3332 (write _test-input-stream "fn f {\n") + 3333 (write _test-input-stream " var x/eax: int <- g\n") + 3334 (write _test-input-stream "}\n") + 3335 (write _test-input-stream "fn g {\n") + 3336 (write _test-input-stream "}\n") + 3337 # convert + 3338 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3339 # registers except esp clobbered at this point + 3340 # restore ed + 3341 89/<- %edx 4/r32/esp + 3342 (flush _test-output-buffered-file) + 3343 (flush _test-error-buffered-file) + 3344 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3350 # check output + 3351 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-too-many-outputs: output should be empty") + 3352 (check-next-stream-line-equal _test-error-stream "fn f: call g: too many outputs" "F - test-convert-function-call-with-too-many-outputs: error message") + 3353 # check that stop(1) was called + 3354 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-too-many-outputs: exit status") + 3355 # don't restore from ebp + 3356 81 0/subop/add %esp 8/imm32 + 3357 5d/pop-to-ebp + 3358 c3/return + 3359 + 3360 test-convert-function-call-with-missing-output-register: + 3361 # . prologue + 3362 55/push-ebp + 3363 89/<- %ebp 4/r32/esp + 3364 # setup + 3365 (clear-stream _test-input-stream) + 3366 (clear-stream $_test-input-buffered-file->buffer) + 3367 (clear-stream _test-output-stream) + 3368 (clear-stream $_test-output-buffered-file->buffer) + 3369 (clear-stream _test-error-stream) + 3370 (clear-stream $_test-error-buffered-file->buffer) + 3371 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3372 68/push 0/imm32 + 3373 68/push 0/imm32 + 3374 89/<- %edx 4/r32/esp + 3375 (tailor-exit-descriptor %edx 0x10) + 3376 # + 3377 (write _test-input-stream "fn f {\n") + 3378 (write _test-input-stream " var x: int\n") + 3379 (write _test-input-stream " x <- g\n") + 3380 (write _test-input-stream "}\n") + 3381 (write _test-input-stream "fn g -> _/eax: int {\n") + 3382 (write _test-input-stream "}\n") + 3383 # convert + 3384 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3385 # registers except esp clobbered at this point + 3386 # restore ed + 3387 89/<- %edx 4/r32/esp + 3388 (flush _test-output-buffered-file) + 3389 (flush _test-error-buffered-file) + 3390 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3396 # check output + 3397 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-missing-output-register: output should be empty") + 3398 (check-next-stream-line-equal _test-error-stream "fn f: call g: output 'x' is not in a register" "F - test-convert-function-call-with-missing-output-register: error message") + 3399 # check that stop(1) was called + 3400 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-missing-output-register: exit status") + 3401 # don't restore from ebp + 3402 81 0/subop/add %esp 8/imm32 + 3403 5d/pop-to-ebp + 3404 c3/return + 3405 + 3406 test-convert-function-call-with-incorrect-output-register: + 3407 # . prologue + 3408 55/push-ebp + 3409 89/<- %ebp 4/r32/esp + 3410 # setup + 3411 (clear-stream _test-input-stream) + 3412 (clear-stream $_test-input-buffered-file->buffer) + 3413 (clear-stream _test-output-stream) + 3414 (clear-stream $_test-output-buffered-file->buffer) + 3415 (clear-stream _test-error-stream) + 3416 (clear-stream $_test-error-buffered-file->buffer) + 3417 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3418 68/push 0/imm32 + 3419 68/push 0/imm32 + 3420 89/<- %edx 4/r32/esp + 3421 (tailor-exit-descriptor %edx 0x10) + 3422 # + 3423 (write _test-input-stream "fn f {\n") + 3424 (write _test-input-stream " var x/ecx: int <- g\n") + 3425 (write _test-input-stream "}\n") + 3426 (write _test-input-stream "fn g -> _/eax: int {\n") + 3427 (write _test-input-stream "}\n") + 3428 # convert + 3429 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3430 # registers except esp clobbered at this point + 3431 # restore ed + 3432 89/<- %edx 4/r32/esp + 3433 (flush _test-output-buffered-file) + 3434 (flush _test-error-buffered-file) + 3435 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3441 # check output + 3442 (check-stream-equal _test-output-stream "" "F - test-convert-function-call-with-incorrect-output-register: output should be empty") + 3443 (check-next-stream-line-equal _test-error-stream "fn f: call g: register for output 'x' is not right" "F - test-convert-function-call-with-incorrect-output-register: error message") + 3444 # check that stop(1) was called + 3445 (check-ints-equal *(edx+4) 2 "F - test-convert-function-call-with-incorrect-output-register: exit status") + 3446 # don't restore from ebp + 3447 81 0/subop/add %esp 8/imm32 + 3448 5d/pop-to-ebp + 3449 c3/return + 3450 + 3451 test-convert-function-with-local-var-dereferenced: + 3452 # . prologue + 3453 55/push-ebp + 3454 89/<- %ebp 4/r32/esp + 3455 # setup + 3456 (clear-stream _test-input-stream) + 3457 (clear-stream $_test-input-buffered-file->buffer) + 3458 (clear-stream _test-output-stream) + 3459 (clear-stream $_test-output-buffered-file->buffer) + 3460 # + 3461 (write _test-input-stream "fn foo {\n") + 3462 (write _test-input-stream " var x/ecx: (addr int) <- copy 0\n") + 3463 (write _test-input-stream " increment *x\n") + 3464 (write _test-input-stream "}\n") + 3465 # convert + 3466 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3467 (flush _test-output-buffered-file) + 3468 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3474 # check output + 3475 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-dereferenced/0") + 3476 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-dereferenced/1") + 3477 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-dereferenced/2") + 3478 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-dereferenced/3") + 3479 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-dereferenced/4") + 3480 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-dereferenced/5") + 3481 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-local-var-dereferenced/6") + 3482 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-local-var-dereferenced/7") + 3483 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *ecx" "F - test-convert-function-with-local-var-dereferenced/8") + 3484 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-local-var-dereferenced/9") + 3485 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-dereferenced/10") + 3486 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-dereferenced/11") + 3487 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-dereferenced/12") + 3488 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-dereferenced/13") + 3489 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-dereferenced/14") + 3490 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-dereferenced/15") + 3491 # . epilogue + 3492 89/<- %esp 5/r32/ebp + 3493 5d/pop-to-ebp + 3494 c3/return + 3495 + 3496 test-dereference-of-var-on-stack: + 3497 # . prologue + 3498 55/push-ebp + 3499 89/<- %ebp 4/r32/esp + 3500 # setup + 3501 (clear-stream _test-input-stream) + 3502 (clear-stream $_test-input-buffered-file->buffer) + 3503 (clear-stream _test-output-stream) + 3504 (clear-stream $_test-output-buffered-file->buffer) + 3505 (clear-stream _test-error-stream) + 3506 (clear-stream $_test-error-buffered-file->buffer) + 3507 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3508 68/push 0/imm32 + 3509 68/push 0/imm32 + 3510 89/<- %edx 4/r32/esp + 3511 (tailor-exit-descriptor %edx 0x10) + 3512 # + 3513 (write _test-input-stream "fn foo {\n") + 3514 (write _test-input-stream " var x: (addr int)\n") + 3515 (write _test-input-stream " increment *x\n") + 3516 (write _test-input-stream "}\n") + 3517 # convert + 3518 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3519 # registers except esp clobbered at this point + 3520 # restore ed + 3521 89/<- %edx 4/r32/esp + 3522 (flush _test-output-buffered-file) + 3523 (flush _test-error-buffered-file) + 3524 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3530 # check output + 3531 (check-stream-equal _test-output-stream "" "F - test-dereference-of-var-on-stack: output should be empty") + 3532 (check-next-stream-line-equal _test-error-stream "fn foo: cannot dereference var 'x' on stack" "F - test-dereference-of-var-on-stack: error message") + 3533 # check that stop(1) was called + 3534 (check-ints-equal *(edx+4) 2 "F - test-dereference-of-var-on-stack: exit status") + 3535 # don't restore from ebp + 3536 81 0/subop/add %esp 8/imm32 + 3537 # . epilogue + 3538 5d/pop-to-ebp + 3539 c3/return + 3540 + 3541 test-convert-function-with-byte-operations: + 3542 # . prologue + 3543 55/push-ebp + 3544 89/<- %ebp 4/r32/esp + 3545 # setup + 3546 (clear-stream _test-input-stream) + 3547 (clear-stream $_test-input-buffered-file->buffer) + 3548 (clear-stream _test-output-stream) + 3549 (clear-stream $_test-output-buffered-file->buffer) + 3550 # + 3551 (write _test-input-stream "fn foo {\n") + 3552 (write _test-input-stream " var x/eax: byte <- copy 0\n") + 3553 (write _test-input-stream " var y/ecx: byte <- copy 0\n") + 3554 (write _test-input-stream " y <- copy-byte x\n") + 3555 (write _test-input-stream " var z/edx: (addr byte) <- copy 0\n") + 3556 (write _test-input-stream " y <- copy-byte *z\n") + 3557 (write _test-input-stream " copy-byte-to *z, x\n") + 3558 (write _test-input-stream "}\n") + 3559 # convert + 3560 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3561 (flush _test-output-buffered-file) + 3562 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3568 # check output + 3569 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-byte-operations/0") + 3570 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-byte-operations/1") + 3571 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-byte-operations/2") + 3572 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-byte-operations/3") + 3573 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-byte-operations/4") + 3574 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-byte-operations/5") + 3575 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-byte-operations/6") + 3576 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-byte-operations/7") + 3577 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-byte-operations/8") + 3578 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-byte-operations/9") + 3579 (check-next-stream-line-equal _test-output-stream " 8a/byte-> %eax 0x00000001/r32" "F - test-convert-function-with-byte-operations/10") + 3580 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-function-with-byte-operations/11") + 3581 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 0/imm32" "F - test-convert-function-with-byte-operations/12") + 3582 (check-next-stream-line-equal _test-output-stream " 8a/byte-> *edx 0x00000001/r32" "F - test-convert-function-with-byte-operations/13") + 3583 (check-next-stream-line-equal _test-output-stream " 88/byte<- *edx 0x00000000/r32" "F - test-convert-function-with-byte-operations/14") + 3584 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-function-with-byte-operations/15") + 3585 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-byte-operations/16") + 3586 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-byte-operations/17") + 3587 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-byte-operations/18") + 3588 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-byte-operations/19") + 3589 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-byte-operations/20") + 3590 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-byte-operations/21") + 3591 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-byte-operations/22") + 3592 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-byte-operations/23") + 3593 # . epilogue + 3594 89/<- %esp 5/r32/ebp + 3595 5d/pop-to-ebp + 3596 c3/return + 3597 + 3598 # variables of type 'byte' are not allowed on the stack + 3599 test-byte-values-on-stack: + 3600 # . prologue + 3601 55/push-ebp + 3602 89/<- %ebp 4/r32/esp + 3603 # setup + 3604 (clear-stream _test-input-stream) + 3605 (clear-stream $_test-input-buffered-file->buffer) + 3606 (clear-stream _test-output-stream) + 3607 (clear-stream $_test-output-buffered-file->buffer) + 3608 (clear-stream _test-error-stream) + 3609 (clear-stream $_test-error-buffered-file->buffer) + 3610 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3611 68/push 0/imm32 + 3612 68/push 0/imm32 + 3613 89/<- %edx 4/r32/esp + 3614 (tailor-exit-descriptor %edx 0x10) + 3615 # + 3616 (write _test-input-stream "fn foo {\n") + 3617 (write _test-input-stream " var x: byte\n") + 3618 (write _test-input-stream "}\n") + 3619 # convert + 3620 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3621 # registers except esp clobbered at this point + 3622 # restore ed + 3623 89/<- %edx 4/r32/esp + 3624 (flush _test-output-buffered-file) + 3625 (flush _test-error-buffered-file) + 3626 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3632 # check output + 3633 (check-stream-equal _test-output-stream "" "F - test-byte-values-on-stack: output should be empty") + 3634 (check-next-stream-line-equal _test-error-stream "fn foo: var 'x' of type 'byte' cannot be on the stack" "F - test-byte-values-on-stack: error message") + 3635 # check that stop(1) was called + 3636 (check-ints-equal *(edx+4) 2 "F - test-byte-values-on-stack: exit status") + 3637 # don't restore from ebp + 3638 81 0/subop/add %esp 8/imm32 + 3639 # . epilogue + 3640 5d/pop-to-ebp + 3641 c3/return + 3642 + 3643 # variables of type 'byte' are not allowed in esi or edi + 3644 test-byte-values-in-unsupported-registers: + 3645 # . prologue + 3646 55/push-ebp + 3647 89/<- %ebp 4/r32/esp + 3648 # setup + 3649 (clear-stream _test-input-stream) + 3650 (clear-stream $_test-input-buffered-file->buffer) + 3651 (clear-stream _test-output-stream) + 3652 (clear-stream $_test-output-buffered-file->buffer) + 3653 (clear-stream _test-error-stream) + 3654 (clear-stream $_test-error-buffered-file->buffer) + 3655 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3656 68/push 0/imm32 + 3657 68/push 0/imm32 + 3658 89/<- %edx 4/r32/esp + 3659 (tailor-exit-descriptor %edx 0x10) + 3660 # + 3661 (write _test-input-stream "fn foo {\n") + 3662 (write _test-input-stream " var x/esi: byte <- copy 0\n") + 3663 (write _test-input-stream "}\n") + 3664 # convert + 3665 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3666 # registers except esp clobbered at this point + 3667 # restore ed + 3668 89/<- %edx 4/r32/esp + 3669 (flush _test-output-buffered-file) + 3670 (flush _test-error-buffered-file) + 3671 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3677 # check output + 3678 (check-stream-equal _test-output-stream "" "F - test-byte-values-in-unsupported-registers: output should be empty") + 3679 (check-next-stream-line-equal _test-error-stream "fn foo: var 'x' of type 'byte' cannot be in esi or edi" "F - test-byte-values-in-unsupported-registers: error message") + 3680 # check that stop(1) was called + 3681 (check-ints-equal *(edx+4) 2 "F - test-byte-values-in-unsupported-registers: exit status") + 3682 # don't restore from ebp + 3683 81 0/subop/add %esp 8/imm32 + 3684 # . epilogue + 3685 5d/pop-to-ebp + 3686 c3/return + 3687 + 3688 # variables of type 'byte' _can_ be function args. They then occupy 4 bytes. + 3689 test-copy-byte-var-from-fn-arg: + 3690 # . prologue + 3691 55/push-ebp + 3692 89/<- %ebp 4/r32/esp + 3693 # setup + 3694 (clear-stream _test-input-stream) + 3695 (clear-stream $_test-input-buffered-file->buffer) + 3696 (clear-stream _test-output-stream) + 3697 (clear-stream $_test-output-buffered-file->buffer) + 3698 # + 3699 (write _test-input-stream "fn foo x: byte, y: int {\n") + 3700 (write _test-input-stream " var a/eax: byte <- copy x\n") + 3701 (write _test-input-stream " var b/eax: int <- copy y\n") + 3702 (write _test-input-stream "}\n") + 3703 # convert + 3704 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3705 (flush _test-output-buffered-file) + 3706 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3712 # check output + 3713 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-copy-byte-from-fn-arg/0") + 3714 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-copy-byte-from-fn-arg/1") + 3715 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-copy-byte-from-fn-arg/2") + 3716 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-copy-byte-from-fn-arg/3") + 3717 (check-next-stream-line-equal _test-output-stream " {" "F - test-copy-byte-from-fn-arg/4") + 3718 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-copy-byte-from-fn-arg/5") + 3719 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-copy-byte-from-fn-arg/6") + 3720 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/7") + 3721 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x0000000c) 0x00000000/r32" "F - test-copy-byte-from-fn-arg/8") + 3722 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-copy-byte-from-fn-arg/9") + 3723 (check-next-stream-line-equal _test-output-stream " }" "F - test-copy-byte-from-fn-arg/10") + 3724 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-copy-byte-from-fn-arg/11") + 3725 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-copy-byte-from-fn-arg/12") + 3726 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-copy-byte-from-fn-arg/13") + 3727 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-copy-byte-from-fn-arg/14") + 3728 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-copy-byte-from-fn-arg/15") + 3729 # . epilogue + 3730 89/<- %esp 5/r32/ebp + 3731 5d/pop-to-ebp + 3732 c3/return + 3733 + 3734 test-convert-compare-register-with-literal: + 3735 # . prologue + 3736 55/push-ebp + 3737 89/<- %ebp 4/r32/esp + 3738 # setup + 3739 (clear-stream _test-input-stream) + 3740 (clear-stream $_test-input-buffered-file->buffer) + 3741 (clear-stream _test-output-stream) + 3742 (clear-stream $_test-output-buffered-file->buffer) + 3743 # + 3744 (write _test-input-stream "fn foo {\n") + 3745 (write _test-input-stream " var x/ecx: int <- copy 0\n") + 3746 (write _test-input-stream " compare x, 0\n") + 3747 (write _test-input-stream "}\n") + 3748 # convert + 3749 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3750 (flush _test-output-buffered-file) + 3751 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3757 # check output + 3758 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-compare-register-with-literal/0") + 3759 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-compare-register-with-literal/1") + 3760 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-compare-register-with-literal/2") + 3761 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-compare-register-with-literal/3") + 3762 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-compare-register-with-literal/4") + 3763 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-compare-register-with-literal/5") + 3764 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6") + 3765 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-compare-register-with-literal/7") + 3766 (check-next-stream-line-equal _test-output-stream " 81 7/subop/compare %ecx 0/imm32" "F - test-convert-compare-register-with-literal/8") + 3767 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9") + 3768 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-compare-register-with-literal/10") + 3769 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-compare-register-with-literal/11") + 3770 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-compare-register-with-literal/12") + 3771 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-compare-register-with-literal/13") + 3772 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-compare-register-with-literal/14") + 3773 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-compare-register-with-literal/15") + 3774 # . epilogue + 3775 89/<- %esp 5/r32/ebp + 3776 5d/pop-to-ebp + 3777 c3/return + 3778 + 3779 test-unknown-variable: + 3780 # . prologue + 3781 55/push-ebp + 3782 89/<- %ebp 4/r32/esp + 3783 # setup + 3784 (clear-stream _test-input-stream) + 3785 (clear-stream $_test-input-buffered-file->buffer) + 3786 (clear-stream _test-output-stream) + 3787 (clear-stream $_test-output-buffered-file->buffer) + 3788 (clear-stream _test-error-stream) + 3789 (clear-stream $_test-error-buffered-file->buffer) + 3790 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3791 68/push 0/imm32 + 3792 68/push 0/imm32 + 3793 89/<- %edx 4/r32/esp + 3794 (tailor-exit-descriptor %edx 0x10) + 3795 # + 3796 (write _test-input-stream "fn foo {\n") + 3797 (write _test-input-stream " compare x, 0\n") + 3798 (write _test-input-stream "}\n") + 3799 # convert + 3800 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 3801 # registers except esp clobbered at this point + 3802 # restore ed + 3803 89/<- %edx 4/r32/esp + 3804 (flush _test-output-buffered-file) + 3805 (flush _test-error-buffered-file) + 3806 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3812 # check output + 3813 (check-stream-equal _test-output-stream "" "F - test-unknown-variable: output should be empty") + 3814 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable: error message") + 3815 # check that stop(1) was called + 3816 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable: exit status") + 3817 # don't restore from ebp + 3818 81 0/subop/add %esp 8/imm32 + 3819 # . epilogue + 3820 5d/pop-to-ebp + 3821 c3/return + 3822 + 3823 test-convert-function-with-local-var-in-block: + 3824 # . prologue + 3825 55/push-ebp + 3826 89/<- %ebp 4/r32/esp + 3827 # setup + 3828 (clear-stream _test-input-stream) + 3829 (clear-stream $_test-input-buffered-file->buffer) + 3830 (clear-stream _test-output-stream) + 3831 (clear-stream $_test-output-buffered-file->buffer) + 3832 # + 3833 (write _test-input-stream "fn foo {\n") + 3834 (write _test-input-stream " {\n") + 3835 (write _test-input-stream " var x: int\n") + 3836 (write _test-input-stream " increment x\n") 3837 (write _test-input-stream " }\n") 3838 (write _test-input-stream "}\n") 3839 # convert @@ -3558,2248 +3553,2248 @@ if ('onhashchange' in window) { 3841 (flush _test-output-buffered-file) 3842 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3848 # check output - 3849 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0") - 3850 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1") - 3851 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-block/2") - 3852 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-block/3") - 3853 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/4") - 3854 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-block/5") - 3855 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/6") - 3856 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-in-block/7") - 3857 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/8") - 3858 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-block/9") - 3859 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-in-block/10") - 3860 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/11") - 3861 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/12") - 3862 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-block/13") - 3863 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-branches-in-block/14") - 3864 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/15") - 3865 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-block/16") - 3866 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-block/17") - 3867 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/18") - 3868 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-in-block/19") - 3869 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/20") - 3870 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-block/21") - 3871 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-block/22") - 3872 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-block/23") - 3873 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-block/24") - 3874 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-block/25") - 3875 # . epilogue - 3876 89/<- %esp 5/r32/ebp - 3877 5d/pop-to-ebp - 3878 c3/return - 3879 - 3880 test-convert-function-with-branches-in-named-block: - 3881 # . prologue - 3882 55/push-ebp - 3883 89/<- %ebp 4/r32/esp - 3884 # setup - 3885 (clear-stream _test-input-stream) - 3886 (clear-stream $_test-input-buffered-file->buffer) - 3887 (clear-stream _test-output-stream) - 3888 (clear-stream $_test-output-buffered-file->buffer) - 3889 # - 3890 (write _test-input-stream "fn foo x: int {\n") - 3891 (write _test-input-stream " $bar: {\n") - 3892 (write _test-input-stream " break-if->= $bar\n") - 3893 (write _test-input-stream " loop-if-addr< $bar\n") - 3894 (write _test-input-stream " increment x\n") - 3895 (write _test-input-stream " loop\n") - 3896 (write _test-input-stream " }\n") - 3897 (write _test-input-stream "}\n") - 3898 # convert - 3899 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3900 (flush _test-output-buffered-file) - 3901 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3907 # check output - 3908 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-named-block/0") - 3909 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-named-block/1") - 3910 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-named-block/2") - 3911 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-named-block/3") - 3912 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/4") - 3913 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-named-block/5") - 3914 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/6") - 3915 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-branches-in-named-block/7") - 3916 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/8") - 3917 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-named-block/9") - 3918 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:break/disp32" "F - test-convert-function-with-branches-in-named-block/10") - 3919 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/11") - 3920 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/12") - 3921 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-named-block/13") - 3922 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:loop/disp32" "F - test-convert-function-with-branches-in-named-block/14") - 3923 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/15") - 3924 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-named-block/16") - 3925 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-named-block/17") - 3926 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/18") - 3927 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-branches-in-named-block/19") - 3928 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/20") - 3929 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-named-block/21") - 3930 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-named-block/22") - 3931 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-named-block/23") - 3932 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-named-block/24") - 3933 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-named-block/25") - 3934 # . epilogue - 3935 89/<- %esp 5/r32/ebp - 3936 5d/pop-to-ebp - 3937 c3/return - 3938 - 3939 test-convert-function-with-var-in-nested-block: - 3940 # . prologue - 3941 55/push-ebp - 3942 89/<- %ebp 4/r32/esp - 3943 # setup - 3944 (clear-stream _test-input-stream) - 3945 (clear-stream $_test-input-buffered-file->buffer) - 3946 (clear-stream _test-output-stream) - 3947 (clear-stream $_test-output-buffered-file->buffer) - 3948 # - 3949 (write _test-input-stream "fn foo x: int {\n") - 3950 (write _test-input-stream " {\n") - 3951 (write _test-input-stream " {\n") - 3952 (write _test-input-stream " var x: int\n") - 3953 (write _test-input-stream " increment x\n") - 3954 (write _test-input-stream " }\n") - 3955 (write _test-input-stream " }\n") - 3956 (write _test-input-stream "}\n") - 3957 # convert - 3958 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 3959 (flush _test-output-buffered-file) - 3960 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 3966 # check output - 3967 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-var-in-nested-block/0") - 3968 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-var-in-nested-block/1") - 3969 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-var-in-nested-block/2") - 3970 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-var-in-nested-block/3") - 3971 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/4") - 3972 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-var-in-nested-block/5") - 3973 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/6") - 3974 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-var-in-nested-block/7") - 3975 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/8") - 3976 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-var-in-nested-block/9") - 3977 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-var-in-nested-block/10") - 3978 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-var-in-nested-block/11") - 3979 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-var-in-nested-block/12") - 3980 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/13") - 3981 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-var-in-nested-block/14") - 3982 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/15") - 3983 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-var-in-nested-block/16") - 3984 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/17") - 3985 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-var-in-nested-block/18") - 3986 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-var-in-nested-block/19") - 3987 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-var-in-nested-block/20") - 3988 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-var-in-nested-block/21") - 3989 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-var-in-nested-block/22") - 3990 # . epilogue - 3991 89/<- %esp 5/r32/ebp - 3992 5d/pop-to-ebp - 3993 c3/return - 3994 - 3995 test-convert-function-with-multiple-vars-in-nested-blocks: - 3996 # . prologue - 3997 55/push-ebp - 3998 89/<- %ebp 4/r32/esp - 3999 # setup - 4000 (clear-stream _test-input-stream) - 4001 (clear-stream $_test-input-buffered-file->buffer) - 4002 (clear-stream _test-output-stream) - 4003 (clear-stream $_test-output-buffered-file->buffer) - 4004 # - 4005 (write _test-input-stream "fn foo x: int {\n") - 4006 (write _test-input-stream " {\n") - 4007 (write _test-input-stream " var x/eax: int <- copy 0\n") - 4008 (write _test-input-stream " {\n") - 4009 (write _test-input-stream " var y: int\n") - 4010 (write _test-input-stream " x <- add y\n") - 4011 (write _test-input-stream " }\n") - 4012 (write _test-input-stream " }\n") - 4013 (write _test-input-stream "}\n") - 4014 # convert - 4015 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4016 (flush _test-output-buffered-file) - 4017 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4023 # check output - 4024 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/0") - 4025 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/1") - 4026 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/2") - 4027 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/3") - 4028 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/4") - 4029 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/5") - 4030 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/6") - 4031 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/7") - 4032 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/8") - 4033 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/9") - 4034 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/10") - 4035 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/11") - 4036 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/12") - 4037 (check-next-stream-line-equal _test-output-stream " 03/add *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/13") - 4038 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/14") - 4039 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/15") - 4040 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/16") - 4041 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/17") - 4042 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/18") - 4043 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/19") - 4044 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/20") - 4045 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/21") - 4046 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/22") - 4047 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/23") - 4048 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/24") - 4049 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-multiple-vars-in-nested-blocks/25") - 4050 # . epilogue - 4051 89/<- %esp 5/r32/ebp - 4052 5d/pop-to-ebp - 4053 c3/return - 4054 - 4055 test-convert-function-with-branches-and-local-vars: - 4056 # A conditional 'break' after a 'var' in a block is converted into a - 4057 # nested block that performs all necessary cleanup before jumping. This - 4058 # results in some ugly code duplication. - 4059 # . prologue - 4060 55/push-ebp - 4061 89/<- %ebp 4/r32/esp - 4062 # setup - 4063 (clear-stream _test-input-stream) - 4064 (clear-stream $_test-input-buffered-file->buffer) - 4065 (clear-stream _test-output-stream) - 4066 (clear-stream $_test-output-buffered-file->buffer) - 4067 # - 4068 (write _test-input-stream "fn foo {\n") - 4069 (write _test-input-stream " {\n") - 4070 (write _test-input-stream " var x: int\n") - 4071 (write _test-input-stream " break-if->=\n") - 4072 (write _test-input-stream " increment x\n") - 4073 (write _test-input-stream " }\n") - 4074 (write _test-input-stream "}\n") - 4075 # convert - 4076 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4077 (flush _test-output-buffered-file) - 4078 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4084 # check output - 4085 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-local-vars/0") - 4086 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-local-vars/1") - 4087 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-local-vars/2") - 4088 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-local-vars/3") - 4089 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/4") - 4090 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-local-vars/5") - 4091 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/6") - 4092 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-local-vars/7") - 4093 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-local-vars/8") - 4094 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/9") - 4095 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-local-vars/10") - 4096 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/11") - 4097 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-local-vars/12") - 4098 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/13") - 4099 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-local-vars/14") - 4100 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/15") - 4101 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/16") - 4102 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-local-vars/17") - 4103 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/18") - 4104 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-local-vars/19") - 4105 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-local-vars/20") - 4106 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-local-vars/21") - 4107 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-local-vars/22") - 4108 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-local-vars/23") - 4109 # . epilogue - 4110 89/<- %esp 5/r32/ebp - 4111 5d/pop-to-ebp - 4112 c3/return - 4113 - 4114 test-convert-function-with-conditional-loops-and-local-vars: - 4115 # A conditional 'loop' after a 'var' in a block is converted into a nested - 4116 # block that performs all necessary cleanup before jumping. This results - 4117 # in some ugly code duplication. - 4118 # . prologue - 4119 55/push-ebp - 4120 89/<- %ebp 4/r32/esp - 4121 # setup - 4122 (clear-stream _test-input-stream) - 4123 (clear-stream $_test-input-buffered-file->buffer) - 4124 (clear-stream _test-output-stream) - 4125 (clear-stream $_test-output-buffered-file->buffer) - 4126 # - 4127 (write _test-input-stream "fn foo {\n") - 4128 (write _test-input-stream " {\n") - 4129 (write _test-input-stream " var x: int\n") - 4130 (write _test-input-stream " loop-if->=\n") - 4131 (write _test-input-stream " increment x\n") - 4132 (write _test-input-stream " }\n") - 4133 (write _test-input-stream "}\n") - 4134 # convert - 4135 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4136 (flush _test-output-buffered-file) - 4137 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4143 # check output - 4144 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-conditional-loops-and-local-vars/0") - 4145 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-conditional-loops-and-local-vars/1") - 4146 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/2") - 4147 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-conditional-loops-and-local-vars/3") - 4148 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/4") - 4149 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/5") - 4150 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/6") - 4151 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/7") - 4152 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/8") - 4153 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/9") - 4154 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/10") - 4155 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/11") - 4156 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/12") - 4157 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/13") - 4158 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-conditional-loops-and-local-vars/14") - 4159 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/15") - 4160 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/16") - 4161 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/17") - 4162 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/18") - 4163 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/19") - 4164 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-conditional-loops-and-local-vars/20") - 4165 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/21") - 4166 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/22") - 4167 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-conditional-loops-and-local-vars/23") - 4168 # . epilogue - 4169 89/<- %esp 5/r32/ebp - 4170 5d/pop-to-ebp - 4171 c3/return - 4172 - 4173 test-convert-function-with-unconditional-loops-and-local-vars: - 4174 # An unconditional 'loop' after a 'var' in a block is emitted _after_ the - 4175 # regular block cleanup. Any instructions after 'loop' are dead and - 4176 # therefore skipped. - 4177 # . prologue - 4178 55/push-ebp - 4179 89/<- %ebp 4/r32/esp - 4180 # setup - 4181 (clear-stream _test-input-stream) - 4182 (clear-stream $_test-input-buffered-file->buffer) - 4183 (clear-stream _test-output-stream) - 4184 (clear-stream $_test-output-buffered-file->buffer) - 4185 # - 4186 (write _test-input-stream "fn foo {\n") + 3849 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-block/0") + 3850 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-block/1") + 3851 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-block/2") + 3852 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-block/3") + 3853 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/4") + 3854 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-block/5") + 3855 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-block/6") + 3856 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-local-var-in-block/7") + 3857 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-block/8") + 3858 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-block/9") + 3859 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-block/10") + 3860 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/11") + 3861 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-local-var-in-block/12") + 3862 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-block/13") + 3863 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-block/14") + 3864 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-block/15") + 3865 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-block/16") + 3866 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-block/17") + 3867 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-block/18") + 3868 # . epilogue + 3869 89/<- %esp 5/r32/ebp + 3870 5d/pop-to-ebp + 3871 c3/return + 3872 + 3873 test-convert-function-with-local-var-in-mem-after-block: + 3874 # . prologue + 3875 55/push-ebp + 3876 89/<- %ebp 4/r32/esp + 3877 # setup + 3878 (clear-stream _test-input-stream) + 3879 (clear-stream $_test-input-buffered-file->buffer) + 3880 (clear-stream _test-output-stream) + 3881 (clear-stream $_test-output-buffered-file->buffer) + 3882 # + 3883 (write _test-input-stream "fn foo {\n") + 3884 (write _test-input-stream " {\n") + 3885 (write _test-input-stream " var y: int\n") + 3886 (write _test-input-stream " }\n") + 3887 (write _test-input-stream " var x: int\n") + 3888 (write _test-input-stream " increment x\n") + 3889 (write _test-input-stream "}\n") + 3890 # convert + 3891 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3892 (flush _test-output-buffered-file) + 3893 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3899 # check output + 3900 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-mem-after-block/0") + 3901 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-mem-after-block/1") + 3902 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-mem-after-block/2") + 3903 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-mem-after-block/3") + 3904 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-mem-after-block/4") + 3905 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-mem-after-block/5") + 3906 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-mem-after-block/6") + 3907 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-local-var-in-mem-after-block/7") + 3908 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/8") + 3909 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/9") + 3910 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-mem-after-block/10") + 3911 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-local-var-in-mem-after-block/11") + 3912 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/12") + 3913 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-mem-after-block/13") + 3914 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-mem-after-block/14") + 3915 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-mem-after-block/15") + 3916 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-mem-after-block/16") + 3917 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-mem-after-block/17") + 3918 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-mem-after-block/18") + 3919 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-mem-after-block/19") + 3920 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-mem-after-block/20") + 3921 # . epilogue + 3922 89/<- %esp 5/r32/ebp + 3923 5d/pop-to-ebp + 3924 c3/return + 3925 + 3926 test-convert-function-with-local-var-in-named-block: + 3927 # . prologue + 3928 55/push-ebp + 3929 89/<- %ebp 4/r32/esp + 3930 # setup + 3931 (clear-stream _test-input-stream) + 3932 (clear-stream $_test-input-buffered-file->buffer) + 3933 (clear-stream _test-output-stream) + 3934 (clear-stream $_test-output-buffered-file->buffer) + 3935 # + 3936 (write _test-input-stream "fn foo {\n") + 3937 (write _test-input-stream " $bar: {\n") + 3938 (write _test-input-stream " var x: int\n") + 3939 (write _test-input-stream " increment x\n") + 3940 (write _test-input-stream " }\n") + 3941 (write _test-input-stream "}\n") + 3942 # convert + 3943 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 3944 (flush _test-output-buffered-file) + 3945 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 3951 # check output + 3952 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-in-named-block/0") + 3953 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-in-named-block/1") + 3954 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-in-named-block/2") + 3955 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-in-named-block/3") + 3956 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/4") + 3957 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-in-named-block/5") + 3958 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-in-named-block/6") + 3959 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-local-var-in-named-block/7") + 3960 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-in-named-block/8") + 3961 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-local-var-in-named-block/9") + 3962 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-in-named-block/10") + 3963 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/11") + 3964 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-local-var-in-named-block/12") + 3965 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-in-named-block/13") + 3966 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-in-named-block/14") + 3967 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-in-named-block/15") + 3968 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-in-named-block/16") + 3969 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-in-named-block/17") + 3970 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-in-named-block/18") + 3971 # . epilogue + 3972 89/<- %esp 5/r32/ebp + 3973 5d/pop-to-ebp + 3974 c3/return + 3975 + 3976 test-unknown-variable-in-named-block: + 3977 # . prologue + 3978 55/push-ebp + 3979 89/<- %ebp 4/r32/esp + 3980 # setup + 3981 (clear-stream _test-input-stream) + 3982 (clear-stream $_test-input-buffered-file->buffer) + 3983 (clear-stream _test-output-stream) + 3984 (clear-stream $_test-output-buffered-file->buffer) + 3985 (clear-stream _test-error-stream) + 3986 (clear-stream $_test-error-buffered-file->buffer) + 3987 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 3988 68/push 0/imm32 + 3989 68/push 0/imm32 + 3990 89/<- %edx 4/r32/esp + 3991 (tailor-exit-descriptor %edx 0x10) + 3992 # + 3993 (write _test-input-stream "fn foo {\n") + 3994 (write _test-input-stream " $a: {\n") + 3995 (write _test-input-stream " compare x, 0\n") + 3996 (write _test-input-stream " }\n") + 3997 (write _test-input-stream "}\n") + 3998 # convert + 3999 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 4000 # registers except esp clobbered at this point + 4001 # restore ed + 4002 89/<- %edx 4/r32/esp + 4003 (flush _test-output-buffered-file) + 4004 (flush _test-error-buffered-file) + 4005 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4011 # check output + 4012 (check-stream-equal _test-output-stream "" "F - test-unknown-variable-in-named-block: output should be empty") + 4013 (check-next-stream-line-equal _test-error-stream "fn foo: unknown variable 'x'" "F - test-unknown-variable-in-named-block: error message") + 4014 # check that stop(1) was called + 4015 (check-ints-equal *(edx+4) 2 "F - test-unknown-variable-in-named-block: exit status") + 4016 # don't restore from ebp + 4017 81 0/subop/add %esp 8/imm32 + 4018 # . epilogue + 4019 5d/pop-to-ebp + 4020 c3/return + 4021 + 4022 test-always-shadow-outermost-reg-vars-in-function: + 4023 # . prologue + 4024 55/push-ebp + 4025 89/<- %ebp 4/r32/esp + 4026 # setup + 4027 (clear-stream _test-input-stream) + 4028 (clear-stream $_test-input-buffered-file->buffer) + 4029 (clear-stream _test-output-stream) + 4030 (clear-stream $_test-output-buffered-file->buffer) + 4031 # + 4032 (write _test-input-stream "fn foo {\n") + 4033 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 4034 (write _test-input-stream "}\n") + 4035 # convert + 4036 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4037 (flush _test-output-buffered-file) + 4038 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4044 # check output + 4045 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-always-shadow-outermost-reg-vars-in-function/0") + 4046 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-always-shadow-outermost-reg-vars-in-function/1") + 4047 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/2") + 4048 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-always-shadow-outermost-reg-vars-in-function/3") + 4049 (check-next-stream-line-equal _test-output-stream " {" "F - test-always-shadow-outermost-reg-vars-in-function/4") + 4050 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-always-shadow-outermost-reg-vars-in-function/5") + 4051 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-compare-register-with-literal/6") + 4052 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-always-shadow-outermost-reg-vars-in-function/8") + 4053 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-compare-register-with-literal/9") + 4054 (check-next-stream-line-equal _test-output-stream " }" "F - test-always-shadow-outermost-reg-vars-in-function/12") + 4055 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-always-shadow-outermost-reg-vars-in-function/13") + 4056 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-always-shadow-outermost-reg-vars-in-function/14") + 4057 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-always-shadow-outermost-reg-vars-in-function/15") + 4058 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-always-shadow-outermost-reg-vars-in-function/16") + 4059 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-always-shadow-outermost-reg-vars-in-function/17") + 4060 # . epilogue + 4061 89/<- %esp 5/r32/ebp + 4062 5d/pop-to-ebp + 4063 c3/return + 4064 + 4065 test-shadow-local: + 4066 # . prologue + 4067 55/push-ebp + 4068 89/<- %ebp 4/r32/esp + 4069 # setup + 4070 (clear-stream _test-input-stream) + 4071 (clear-stream $_test-input-buffered-file->buffer) + 4072 (clear-stream _test-output-stream) + 4073 (clear-stream $_test-output-buffered-file->buffer) + 4074 # + 4075 (write _test-input-stream "fn foo {\n") + 4076 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 4077 (write _test-input-stream " {\n") + 4078 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 4079 (write _test-input-stream " }\n") + 4080 (write _test-input-stream " x <- increment\n") + 4081 (write _test-input-stream "}\n") + 4082 # convert + 4083 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4084 (flush _test-output-buffered-file) + 4085 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4091 # check output + 4092 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-local/0") + 4093 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-local/1") + 4094 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-local/2") + 4095 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-local/3") + 4096 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-local/4") + 4097 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-local/5") + 4098 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-local/6") + 4099 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-local/7") + 4100 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-local/8") + 4101 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-local/9") + 4102 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-local/10") + 4103 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-shadow-local/11") + 4104 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-local/12") + 4105 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-local/13") + 4106 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-local/14") + 4107 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-local/15") + 4108 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-local/16") + 4109 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-local/17") + 4110 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-local/18") + 4111 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-local/19") + 4112 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-local/20") + 4113 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-local/21") + 4114 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-local/22") + 4115 # . epilogue + 4116 89/<- %esp 5/r32/ebp + 4117 5d/pop-to-ebp + 4118 c3/return + 4119 + 4120 test-shadow-name: + 4121 # . prologue + 4122 55/push-ebp + 4123 89/<- %ebp 4/r32/esp + 4124 # setup + 4125 (clear-stream _test-input-stream) + 4126 (clear-stream $_test-input-buffered-file->buffer) + 4127 (clear-stream _test-output-stream) + 4128 (clear-stream $_test-output-buffered-file->buffer) + 4129 # + 4130 (write _test-input-stream "fn foo {\n") + 4131 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 4132 (write _test-input-stream " {\n") + 4133 (write _test-input-stream " var x/edx: int <- copy 4\n") + 4134 (write _test-input-stream " }\n") + 4135 (write _test-input-stream " x <- increment\n") + 4136 (write _test-input-stream "}\n") + 4137 # convert + 4138 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4139 (flush _test-output-buffered-file) + 4140 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4146 # check output + 4147 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name/0") + 4148 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name/1") + 4149 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name/2") + 4150 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name/3") + 4151 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/4") + 4152 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name/5") + 4153 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name/6") + 4154 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name/7") + 4155 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name/8") + 4156 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name/9") + 4157 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name/10") + 4158 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name/11") + 4159 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name/12") + 4160 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/13") + 4161 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name/14") + 4162 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name/15") + 4163 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name/16") + 4164 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name/17") + 4165 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name/18") + 4166 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name/19") + 4167 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name/20") + 4168 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name/21") + 4169 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name/22") + 4170 # . epilogue + 4171 89/<- %esp 5/r32/ebp + 4172 5d/pop-to-ebp + 4173 c3/return + 4174 + 4175 test-shadow-name-2: + 4176 # . prologue + 4177 55/push-ebp + 4178 89/<- %ebp 4/r32/esp + 4179 # setup + 4180 (clear-stream _test-input-stream) + 4181 (clear-stream $_test-input-buffered-file->buffer) + 4182 (clear-stream _test-output-stream) + 4183 (clear-stream $_test-output-buffered-file->buffer) + 4184 # + 4185 (write _test-input-stream "fn foo {\n") + 4186 (write _test-input-stream " var x/ecx: int <- copy 3\n") 4187 (write _test-input-stream " {\n") - 4188 (write _test-input-stream " var x: int\n") - 4189 (write _test-input-stream " loop\n") - 4190 (write _test-input-stream " increment x\n") - 4191 (write _test-input-stream " }\n") + 4188 (write _test-input-stream " var x/edx: int <- copy 4\n") + 4189 (write _test-input-stream " var y/ecx: int <- copy 5\n") + 4190 (write _test-input-stream " }\n") + 4191 (write _test-input-stream " x <- increment\n") 4192 (write _test-input-stream "}\n") 4193 # convert 4194 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 4195 (flush _test-output-buffered-file) 4196 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 4202 # check output - 4203 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-loops-and-local-vars/0") - 4204 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-loops-and-local-vars/1") - 4205 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/2") - 4206 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-loops-and-local-vars/3") - 4207 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/4") - 4208 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/5") - 4209 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/6") - 4210 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/7") - 4211 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/8") - 4212 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/9") - 4213 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-unconditional-loops-and-local-vars/10") - 4214 # not emitted: ff 0/subop/increment *(ebp+0xfffffffc) - 4215 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/11") - 4216 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/12") - 4217 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/13") - 4218 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/14") - 4219 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-loops-and-local-vars/15") - 4220 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/16") - 4221 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/17") - 4222 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-loops-and-local-vars/18") - 4223 # . epilogue - 4224 89/<- %esp 5/r32/ebp - 4225 5d/pop-to-ebp - 4226 c3/return - 4227 - 4228 test-convert-function-with-branches-and-loops-and-local-vars: - 4229 # . prologue - 4230 55/push-ebp - 4231 89/<- %ebp 4/r32/esp - 4232 # setup - 4233 (clear-stream _test-input-stream) - 4234 (clear-stream $_test-input-buffered-file->buffer) - 4235 (clear-stream _test-output-stream) - 4236 (clear-stream $_test-output-buffered-file->buffer) - 4237 # - 4238 (write _test-input-stream "fn foo {\n") - 4239 (write _test-input-stream " {\n") - 4240 (write _test-input-stream " var x: int\n") - 4241 (write _test-input-stream " break-if->=\n") - 4242 (write _test-input-stream " increment x\n") - 4243 (write _test-input-stream " loop\n") - 4244 (write _test-input-stream " }\n") - 4245 (write _test-input-stream "}\n") - 4246 # convert - 4247 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4248 (flush _test-output-buffered-file) - 4249 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4255 # check output - 4256 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-loops-and-local-vars/0") - 4257 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-loops-and-local-vars/1") - 4258 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/2") - 4259 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-loops-and-local-vars/3") - 4260 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/4") - 4261 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/5") - 4262 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/6") - 4263 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/7") - 4264 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/8") - 4265 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/9") - 4266 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/10") - 4267 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/11") - 4268 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/12") - 4269 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/13") - 4270 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-loops-and-local-vars/14") - 4271 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/15") - 4272 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/16") - 4273 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/17") - 4274 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/18") - 4275 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/19") - 4276 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/20") - 4277 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-loops-and-local-vars/21") - 4278 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/22") - 4279 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/23") - 4280 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-loops-and-local-vars/24") - 4281 # . epilogue - 4282 89/<- %esp 5/r32/ebp - 4283 5d/pop-to-ebp - 4284 c3/return - 4285 - 4286 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars: - 4287 # . prologue - 4288 55/push-ebp - 4289 89/<- %ebp 4/r32/esp - 4290 # setup - 4291 (clear-stream _test-input-stream) - 4292 (clear-stream $_test-input-buffered-file->buffer) - 4293 (clear-stream _test-output-stream) - 4294 (clear-stream $_test-output-buffered-file->buffer) - 4295 # - 4296 (write _test-input-stream "fn foo {\n") - 4297 (write _test-input-stream " a: {\n") - 4298 (write _test-input-stream " var x: int\n") - 4299 (write _test-input-stream " {\n") - 4300 (write _test-input-stream " var y: int\n") - 4301 (write _test-input-stream " break-if->= a\n") - 4302 (write _test-input-stream " increment x\n") - 4303 (write _test-input-stream " loop\n") - 4304 (write _test-input-stream " }\n") - 4305 (write _test-input-stream " }\n") - 4306 (write _test-input-stream "}\n") - 4307 # convert - 4308 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4309 (flush _test-output-buffered-file) - 4310 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4316 # check output - 4317 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/0") - 4318 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/1") - 4319 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/2") - 4320 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/3") - 4321 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/4") - 4322 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/5") - 4323 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/6") - 4324 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/7") - 4325 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/8") - 4326 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/9") - 4327 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/10") - 4328 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/11") - 4329 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/12") - 4330 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/13") - 4331 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/14") - 4332 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/15") - 4333 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/16") - 4334 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/17") - 4335 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/18") - 4336 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/19") - 4337 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/20") - 4338 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/21") - 4339 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/22") - 4340 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/23") - 4341 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/24") - 4342 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/25") - 4343 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/26") - 4344 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/27") - 4345 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/28") - 4346 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/29") - 4347 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/30") - 4348 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/31") - 4349 # . epilogue - 4350 89/<- %esp 5/r32/ebp - 4351 5d/pop-to-ebp - 4352 c3/return - 4353 - 4354 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2: - 4355 # . prologue - 4356 55/push-ebp - 4357 89/<- %ebp 4/r32/esp - 4358 # setup - 4359 (clear-stream _test-input-stream) - 4360 (clear-stream $_test-input-buffered-file->buffer) - 4361 (clear-stream _test-output-stream) - 4362 (clear-stream $_test-output-buffered-file->buffer) - 4363 # non-local conditional branch from a block without a local variable, - 4364 # unwinding a local on the stack - 4365 (write _test-input-stream "fn foo {\n") - 4366 (write _test-input-stream " a: {\n") - 4367 (write _test-input-stream " var x: int\n") - 4368 (write _test-input-stream " {\n") - 4369 (write _test-input-stream " break-if->= a\n") - 4370 (write _test-input-stream " }\n") - 4371 (write _test-input-stream " }\n") - 4372 (write _test-input-stream "}\n") - 4373 # convert - 4374 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4375 (flush _test-output-buffered-file) - 4376 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4382 # check output - 4383 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/0") - 4384 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/1") - 4385 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/2") - 4386 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/3") - 4387 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/4") - 4388 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/5") - 4389 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/6") - 4390 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/7") - 4391 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/8") - 4392 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/9") - 4393 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/10") - 4394 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/11") - 4395 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/12") - 4396 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/13") - 4397 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/14") - 4398 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/15") - 4399 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/16") - 4400 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/17") - 4401 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/18") - 4402 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/19") - 4403 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/20") - 4404 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/21") - 4405 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/22") - 4406 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/23") - 4407 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/24") - 4408 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/25") - 4409 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/26") - 4410 # . epilogue - 4411 89/<- %esp 5/r32/ebp - 4412 5d/pop-to-ebp - 4413 c3/return - 4414 - 4415 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3: - 4416 # . prologue - 4417 55/push-ebp - 4418 89/<- %ebp 4/r32/esp - 4419 # setup - 4420 (clear-stream _test-input-stream) - 4421 (clear-stream $_test-input-buffered-file->buffer) - 4422 (clear-stream _test-output-stream) - 4423 (clear-stream $_test-output-buffered-file->buffer) - 4424 # non-local unconditional branch from a block without a local variable, - 4425 # unwinding a local on the stack - 4426 (write _test-input-stream "fn foo {\n") - 4427 (write _test-input-stream " a: {\n") - 4428 (write _test-input-stream " var x: int\n") - 4429 (write _test-input-stream " {\n") - 4430 (write _test-input-stream " break a\n") - 4431 (write _test-input-stream " }\n") - 4432 (write _test-input-stream " }\n") - 4433 (write _test-input-stream "}\n") - 4434 # convert - 4435 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4436 (flush _test-output-buffered-file) - 4437 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4443 # check output - 4444 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/0") - 4445 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/1") - 4446 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/2") - 4447 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/3") - 4448 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/4") - 4449 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/5") - 4450 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/6") - 4451 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/7") - 4452 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/8") - 4453 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/9") - 4454 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/10") - 4455 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/11") - 4456 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/12") - 4457 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/14") - 4458 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/15") - 4459 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/16") - 4460 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/17") - 4461 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/18") - 4462 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/19") - 4463 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/20") - 4464 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/21") - 4465 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/22") - 4466 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/23") - 4467 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/24") - 4468 # . epilogue - 4469 89/<- %esp 5/r32/ebp - 4470 5d/pop-to-ebp - 4471 c3/return - 4472 - 4473 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4: - 4474 # . prologue - 4475 55/push-ebp - 4476 89/<- %ebp 4/r32/esp - 4477 # setup - 4478 (clear-stream _test-input-stream) - 4479 (clear-stream $_test-input-buffered-file->buffer) - 4480 (clear-stream _test-output-stream) - 4481 (clear-stream $_test-output-buffered-file->buffer) - 4482 # - 4483 (write _test-input-stream "fn foo {\n") - 4484 (write _test-input-stream " a: {\n") - 4485 (write _test-input-stream " var x/esi: int <- copy 0\n") - 4486 (write _test-input-stream " {\n") - 4487 (write _test-input-stream " break a\n") - 4488 (write _test-input-stream " }\n") - 4489 (write _test-input-stream " }\n") - 4490 (write _test-input-stream "}\n") - 4491 # convert - 4492 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4493 (flush _test-output-buffered-file) - 4494 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4500 # check output - 4501 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/0") - 4502 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/1") - 4503 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/2") - 4504 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/3") - 4505 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/4") - 4506 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/5") - 4507 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/6") - 4508 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/7") - 4509 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/8") - 4510 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/9") - 4511 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/10") - 4512 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/11") - 4513 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/12") - 4514 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/13") - 4515 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/14") - 4516 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/15") - 4517 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/16") - 4518 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/17") - 4519 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/18") - 4520 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/19") - 4521 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/20") - 4522 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/21") - 4523 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/22") - 4524 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/23") - 4525 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/24") - 4526 # . epilogue - 4527 89/<- %esp 5/r32/ebp - 4528 5d/pop-to-ebp - 4529 c3/return - 4530 - 4531 test-convert-function-with-nonlocal-unconditional-break-and-local-vars: - 4532 # . prologue - 4533 55/push-ebp - 4534 89/<- %ebp 4/r32/esp - 4535 # setup - 4536 (clear-stream _test-input-stream) - 4537 (clear-stream $_test-input-buffered-file->buffer) - 4538 (clear-stream _test-output-stream) - 4539 (clear-stream $_test-output-buffered-file->buffer) - 4540 # - 4541 (write _test-input-stream "fn foo {\n") - 4542 (write _test-input-stream " a: {\n") - 4543 (write _test-input-stream " var x: int\n") - 4544 (write _test-input-stream " {\n") - 4545 (write _test-input-stream " var y: int\n") - 4546 (write _test-input-stream " break a\n") - 4547 (write _test-input-stream " increment x\n") - 4548 (write _test-input-stream " }\n") - 4549 (write _test-input-stream " }\n") - 4550 (write _test-input-stream "}\n") - 4551 # convert - 4552 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4553 (flush _test-output-buffered-file) - 4554 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4560 # check output - 4561 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/0") - 4562 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/1") - 4563 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/2") - 4564 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/3") - 4565 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/4") - 4566 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/5") - 4567 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/6") - 4568 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/7") - 4569 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/8") - 4570 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/9") - 4571 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/10") - 4572 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/11") - 4573 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/12") - 4574 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/13") - 4575 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/14") - 4576 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/15") - 4577 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/16") - 4578 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/17") - 4579 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/18") - 4580 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/19") - 4581 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/20") - 4582 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/21") - 4583 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/22") - 4584 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/23") - 4585 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/24") - 4586 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/25") - 4587 # . epilogue - 4588 89/<- %esp 5/r32/ebp - 4589 5d/pop-to-ebp - 4590 c3/return - 4591 - 4592 test-convert-function-with-unconditional-break-and-local-vars: - 4593 # . prologue - 4594 55/push-ebp - 4595 89/<- %ebp 4/r32/esp - 4596 # setup - 4597 (clear-stream _test-input-stream) - 4598 (clear-stream $_test-input-buffered-file->buffer) - 4599 (clear-stream _test-output-stream) - 4600 (clear-stream $_test-output-buffered-file->buffer) - 4601 # - 4602 (write _test-input-stream "fn foo {\n") - 4603 (write _test-input-stream " {\n") - 4604 (write _test-input-stream " var x: int\n") - 4605 (write _test-input-stream " {\n") - 4606 (write _test-input-stream " var y: int\n") - 4607 (write _test-input-stream " break\n") - 4608 (write _test-input-stream " increment x\n") - 4609 (write _test-input-stream " }\n") - 4610 (write _test-input-stream " }\n") - 4611 (write _test-input-stream "}\n") - 4612 # convert - 4613 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4614 (flush _test-output-buffered-file) - 4615 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4621 # check output - 4622 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-break-and-local-vars/0") - 4623 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-break-and-local-vars/1") - 4624 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/2") - 4625 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-break-and-local-vars/3") - 4626 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/4") - 4627 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/5") - 4628 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/6") - 4629 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/7") - 4630 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/8") - 4631 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/9") - 4632 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/10") - 4633 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/11") - 4634 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/12") - 4635 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/13") - 4636 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/14") - 4637 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/15") - 4638 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/16") - 4639 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/17") - 4640 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/18") - 4641 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/19") - 4642 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-break-and-local-vars/20") - 4643 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/21") - 4644 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/22") - 4645 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-break-and-local-vars/23") - 4646 # . epilogue - 4647 89/<- %esp 5/r32/ebp - 4648 5d/pop-to-ebp - 4649 c3/return - 4650 - 4651 test-convert-function-with-nonlocal-unconditional-loop-and-local-vars: - 4652 # . prologue - 4653 55/push-ebp - 4654 89/<- %ebp 4/r32/esp - 4655 # setup - 4656 (clear-stream _test-input-stream) - 4657 (clear-stream $_test-input-buffered-file->buffer) - 4658 (clear-stream _test-output-stream) - 4659 (clear-stream $_test-output-buffered-file->buffer) - 4660 # - 4661 (write _test-input-stream "fn foo {\n") - 4662 (write _test-input-stream " a: {\n") - 4663 (write _test-input-stream " var x: int\n") - 4664 (write _test-input-stream " {\n") - 4665 (write _test-input-stream " var y: int\n") - 4666 (write _test-input-stream " loop a\n") - 4667 (write _test-input-stream " increment x\n") - 4668 (write _test-input-stream " }\n") - 4669 (write _test-input-stream " }\n") - 4670 (write _test-input-stream "}\n") - 4671 # convert - 4672 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4673 (flush _test-output-buffered-file) - 4674 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4680 # check output - 4681 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/0") - 4682 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/1") - 4683 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/2") - 4684 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/3") - 4685 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/4") - 4686 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/5") - 4687 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/6") - 4688 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/7") - 4689 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/8") - 4690 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/9") - 4691 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/10") - 4692 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/11") - 4693 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/12") - 4694 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/13") - 4695 (check-next-stream-line-equal _test-output-stream " e9/jump a:loop/disp32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/14") - 4696 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/15") - 4697 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/16") - 4698 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/17") - 4699 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/18") - 4700 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/19") - 4701 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/20") - 4702 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/21") - 4703 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/22") - 4704 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/23") - 4705 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/24") - 4706 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/25") - 4707 # . epilogue - 4708 89/<- %esp 5/r32/ebp - 4709 5d/pop-to-ebp - 4710 c3/return - 4711 - 4712 test-convert-function-with-local-array-var-in-mem: - 4713 # . prologue - 4714 55/push-ebp - 4715 89/<- %ebp 4/r32/esp - 4716 # setup - 4717 (clear-stream _test-input-stream) - 4718 (clear-stream $_test-input-buffered-file->buffer) - 4719 (clear-stream _test-output-stream) - 4720 (clear-stream $_test-output-buffered-file->buffer) - 4721 # - 4722 (write _test-input-stream "fn foo {\n") - 4723 (write _test-input-stream " var x: (array int 3)\n") - 4724 (write _test-input-stream "}\n") - 4725 # convert - 4726 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4727 (flush _test-output-buffered-file) - 4728 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4734 # check output - 4735 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-var-in-mem/0") - 4736 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-var-in-mem/1") - 4737 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-var-in-mem/2") - 4738 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-var-in-mem/3") - 4739 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-var-in-mem/4") - 4740 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-var-in-mem/5") - 4741 # define x - 4742 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-function-with-local-array-var-in-mem/7") - 4743 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-function-with-local-array-var-in-mem/8") - 4744 # reclaim x - 4745 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-function-with-local-array-var-in-mem/9") - 4746 # - 4747 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-var-in-mem/10") - 4748 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-var-in-mem/11") - 4749 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-var-in-mem/12") - 4750 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-var-in-mem/13") - 4751 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-var-in-mem/14") - 4752 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-var-in-mem/15") - 4753 # . epilogue - 4754 89/<- %esp 5/r32/ebp - 4755 5d/pop-to-ebp - 4756 c3/return - 4757 - 4758 test-array-size-in-hex: - 4759 # . prologue - 4760 55/push-ebp - 4761 89/<- %ebp 4/r32/esp - 4762 # setup - 4763 (clear-stream _test-input-stream) - 4764 (clear-stream $_test-input-buffered-file->buffer) - 4765 (clear-stream _test-output-stream) - 4766 (clear-stream $_test-output-buffered-file->buffer) - 4767 (clear-stream _test-error-stream) - 4768 (clear-stream $_test-error-buffered-file->buffer) - 4769 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 4770 68/push 0/imm32 - 4771 68/push 0/imm32 - 4772 89/<- %edx 4/r32/esp - 4773 (tailor-exit-descriptor %edx 0x10) - 4774 # - 4775 (write _test-input-stream "fn foo {\n") - 4776 (write _test-input-stream " var x: (array int 10)\n") - 4777 (write _test-input-stream "}\n") - 4778 # convert - 4779 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 4780 # registers except esp clobbered at this point - 4781 # restore ed - 4782 89/<- %edx 4/r32/esp - 4783 (flush _test-output-buffered-file) - 4784 (flush _test-error-buffered-file) - 4785 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4791 # check output - 4792 (check-stream-equal _test-output-stream "" "F - test-array-size-in-hex: output should be empty") - 4793 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; start '10' with a '0x' to be unambiguous, converting it to hexadecimal as necessary." "F - test-array-size-in-hex: error message") - 4794 # check that stop(1) was called - 4795 (check-ints-equal *(edx+4) 2 "F - test-array-size-in-hex: exit status") - 4796 # don't restore from ebp - 4797 81 0/subop/add %esp 8/imm32 - 4798 # . epilogue - 4799 5d/pop-to-ebp - 4800 c3/return - 4801 - 4802 test-convert-function-with-populate: - 4803 # . prologue - 4804 55/push-ebp - 4805 89/<- %ebp 4/r32/esp - 4806 # setup - 4807 (clear-stream _test-input-stream) - 4808 (clear-stream $_test-input-buffered-file->buffer) - 4809 (clear-stream _test-output-stream) - 4810 (clear-stream $_test-output-buffered-file->buffer) - 4811 # - 4812 (write _test-input-stream "fn foo {\n") - 4813 (write _test-input-stream " var x/ecx: (addr handle array int) <- copy 0\n") - 4814 (write _test-input-stream " populate x, 7\n") - 4815 (write _test-input-stream "}\n") - 4816 # convert - 4817 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4818 (flush _test-output-buffered-file) - 4819 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4825 # check output - 4826 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-populate/0") - 4827 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-populate/1") - 4828 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-populate/2") - 4829 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-populate/3") - 4830 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-populate/4") - 4831 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-populate/5") - 4832 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-populate/6") - 4833 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-populate/7") - 4834 (check-next-stream-line-equal _test-output-stream " (allocate-array2 Heap 0x00000004 7 %ecx)" "F - test-convert-function-with-populate/8") # 4 = size-of(int) - 4835 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-populate/9") - 4836 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-populate/10") - 4837 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-populate/11") - 4838 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-populate/12") - 4839 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-populate/13") - 4840 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-populate/14") - 4841 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-populate/15") - 4842 # . epilogue - 4843 89/<- %esp 5/r32/ebp - 4844 5d/pop-to-ebp - 4845 c3/return - 4846 - 4847 # special-case for size(byte) when allocating array - 4848 test-convert-function-with-local-array-of-bytes-in-mem: - 4849 # . prologue - 4850 55/push-ebp - 4851 89/<- %ebp 4/r32/esp - 4852 # setup - 4853 (clear-stream _test-input-stream) - 4854 (clear-stream $_test-input-buffered-file->buffer) - 4855 (clear-stream _test-output-stream) - 4856 (clear-stream $_test-output-buffered-file->buffer) - 4857 # - 4858 (write _test-input-stream "fn foo {\n") - 4859 (write _test-input-stream " var x: (array byte 3)\n") - 4860 (write _test-input-stream "}\n") - 4861 # convert - 4862 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4863 (flush _test-output-buffered-file) - 4864 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4870 # check output - 4871 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-of-bytes-in-mem/0") - 4872 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-of-bytes-in-mem/1") - 4873 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/2") - 4874 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-of-bytes-in-mem/3") - 4875 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-of-bytes-in-mem/4") - 4876 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-of-bytes-in-mem/5") - 4877 # define x - 4878 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-function-with-local-array-of-bytes-in-mem/7") - 4879 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/8") - 4880 # reclaim x - 4881 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/9") - 4882 # - 4883 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-of-bytes-in-mem/10") - 4884 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-of-bytes-in-mem/11") - 4885 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-of-bytes-in-mem/12") - 4886 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/13") - 4887 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/14") - 4888 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-of-bytes-in-mem/15") - 4889 # . epilogue - 4890 89/<- %esp 5/r32/ebp - 4891 5d/pop-to-ebp - 4892 c3/return - 4893 - 4894 test-convert-address: - 4895 # . prologue - 4896 55/push-ebp - 4897 89/<- %ebp 4/r32/esp - 4898 # setup - 4899 (clear-stream _test-input-stream) - 4900 (clear-stream $_test-input-buffered-file->buffer) - 4901 (clear-stream _test-output-stream) - 4902 (clear-stream $_test-output-buffered-file->buffer) - 4903 # - 4904 (write _test-input-stream "fn foo {\n") - 4905 (write _test-input-stream " var a: int\n") - 4906 (write _test-input-stream " var b/eax: (addr int) <- address a\n") - 4907 (write _test-input-stream "}\n") - 4908 # convert - 4909 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4910 (flush _test-output-buffered-file) - 4911 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4917 # check output - 4918 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-address/0") - 4919 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-address/1") - 4920 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-address/2") - 4921 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-address/3") - 4922 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-address/4") - 4923 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-address/5") - 4924 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-address/6") - 4925 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-address/7") - 4926 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000000/r32" "F - test-convert-address/8") - 4927 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-address/9") - 4928 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-address/10") - 4929 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-address/11") - 4930 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-address/12") - 4931 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-address/13") - 4932 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-address/14") - 4933 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-address/15") - 4934 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-address/16") - 4935 # . epilogue - 4936 89/<- %esp 5/r32/ebp - 4937 5d/pop-to-ebp - 4938 c3/return - 4939 - 4940 test-convert-floating-point-convert: - 4941 # . prologue - 4942 55/push-ebp - 4943 89/<- %ebp 4/r32/esp - 4944 # setup - 4945 (clear-stream _test-input-stream) - 4946 (clear-stream $_test-input-buffered-file->buffer) - 4947 (clear-stream _test-output-stream) - 4948 (clear-stream $_test-output-buffered-file->buffer) - 4949 # - 4950 (write _test-input-stream "fn foo {\n") - 4951 (write _test-input-stream " var a/eax: int <- copy 0\n") - 4952 (write _test-input-stream " var b/xmm1: float <- convert a\n") - 4953 (write _test-input-stream "}\n") - 4954 # convert - 4955 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 4956 (flush _test-output-buffered-file) - 4957 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 4963 # check output - 4964 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-floating-point-convert/0") - 4965 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-convert/1") - 4966 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-convert/2") - 4967 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-convert/3") - 4968 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-convert/4") - 4969 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-floating-point-convert/5") - 4970 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-floating-point-convert/6") - 4971 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-floating-point-convert/7") - 4972 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-convert/8") - 4973 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-convert/9") - 4974 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000001/x32" "F - test-convert-floating-point-convert/10") - 4975 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-convert/11") - 4976 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-floating-point-convert/12") - 4977 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-floating-point-convert/13") - 4978 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-convert/14") - 4979 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-floating-point-convert/15") - 4980 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-convert/16") - 4981 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-convert/17") - 4982 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-convert/18") - 4983 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-convert/19") - 4984 # . epilogue - 4985 89/<- %esp 5/r32/ebp - 4986 5d/pop-to-ebp - 4987 c3/return - 4988 - 4989 test-convert-floating-point-convert-2: - 4990 # . prologue - 4991 55/push-ebp - 4992 89/<- %ebp 4/r32/esp - 4993 # setup - 4994 (clear-stream _test-input-stream) - 4995 (clear-stream $_test-input-buffered-file->buffer) - 4996 (clear-stream _test-output-stream) - 4997 (clear-stream $_test-output-buffered-file->buffer) - 4998 # - 4999 (write _test-input-stream "fn foo {\n") - 5000 (write _test-input-stream " var a/eax: int <- copy 0\n") - 5001 (write _test-input-stream " var b/xmm1: float <- convert a\n") - 5002 (write _test-input-stream " a <- convert b\n") - 5003 (write _test-input-stream "}\n") - 5004 # convert - 5005 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5006 (flush _test-output-buffered-file) - 5007 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5013 # check output - 5014 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-floating-point-convert-2/0") - 5015 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-convert-2/1") - 5016 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-convert-2/2") - 5017 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-convert-2/3") - 5018 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-convert-2/4") - 5019 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-floating-point-convert-2/5") - 5020 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-floating-point-convert-2/6") - 5021 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-floating-point-convert-2/7") - 5022 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-convert-2/8") - 5023 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-convert-2/9") - 5024 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000001/x32" "F - test-convert-floating-point-convert-2/10") - 5025 (check-next-stream-line-equal _test-output-stream " f3 0f 2d/convert-to-int %xmm1 0x00000000/r32" "F - test-convert-floating-point-convert-2/11") - 5026 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-convert-2/12") - 5027 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-floating-point-convert-2/13") - 5028 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-floating-point-convert-2/14") - 5029 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-convert-2/15") - 5030 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-floating-point-convert-2/16") - 5031 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-convert-2/17") - 5032 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-convert-2/18") - 5033 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-convert-2/19") - 5034 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-convert-2/20") - 5035 # . epilogue - 5036 89/<- %esp 5/r32/ebp - 5037 5d/pop-to-ebp - 5038 c3/return - 5039 - 5040 test-convert-floating-point-operation: - 5041 # . prologue - 5042 55/push-ebp - 5043 89/<- %ebp 4/r32/esp - 5044 # setup - 5045 (clear-stream _test-input-stream) - 5046 (clear-stream $_test-input-buffered-file->buffer) - 5047 (clear-stream _test-output-stream) - 5048 (clear-stream $_test-output-buffered-file->buffer) - 5049 # - 5050 (write _test-input-stream "fn f {\n") - 5051 (write _test-input-stream " var m: float\n") - 5052 (write _test-input-stream " var x/xmm1: float <- copy m\n") - 5053 (write _test-input-stream " var y/xmm5: float <- copy m\n") - 5054 (write _test-input-stream " x <- copy y\n") - 5055 (write _test-input-stream " copy-to m, y\n") - 5056 (write _test-input-stream " x <- add y\n") - 5057 (write _test-input-stream " x <- add m\n") - 5058 (write _test-input-stream " x <- subtract y\n") - 5059 (write _test-input-stream " x <- subtract m\n") - 5060 (write _test-input-stream " x <- multiply y\n") - 5061 (write _test-input-stream " x <- multiply m\n") - 5062 (write _test-input-stream " x <- divide y\n") - 5063 (write _test-input-stream " x <- divide m\n") - 5064 (write _test-input-stream " x <- reciprocal y\n") - 5065 (write _test-input-stream " x <- reciprocal m\n") - 5066 (write _test-input-stream " x <- square-root y\n") - 5067 (write _test-input-stream " x <- square-root m\n") - 5068 (write _test-input-stream " x <- inverse-square-root y\n") - 5069 (write _test-input-stream " x <- inverse-square-root m\n") - 5070 (write _test-input-stream " x <- max y\n") - 5071 (write _test-input-stream " x <- max m\n") - 5072 (write _test-input-stream " x <- min y\n") - 5073 (write _test-input-stream " x <- min m\n") - 5074 (write _test-input-stream " compare x, y\n") - 5075 (write _test-input-stream " compare x, m\n") - 5076 (write _test-input-stream "}\n") - 5077 # convert - 5078 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5079 (flush _test-output-buffered-file) - 5080 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5086 # check output - 5087 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-floating-point-operation/0") - 5088 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-operation/1") - 5089 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-operation/2") - 5090 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-operation/3") - 5091 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-operation/4") - 5092 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-floating-point-operation/5") - 5093 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-floating-point-operation/6") - 5094 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-operation/7") - 5095 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-operation/8") - 5096 (check-next-stream-line-equal _test-output-stream " f3 0f 10/copy *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/9") - 5097 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-operation/10") - 5098 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 5/x32" "F - test-convert-floating-point-operation/11") - 5099 (check-next-stream-line-equal _test-output-stream " f3 0f 10/copy *(ebp+0xfffffffc) 0x00000005/x32" "F - test-convert-floating-point-operation/12") - 5100 (check-next-stream-line-equal _test-output-stream " f3 0f 11/copy %xmm1 0x00000005/x32" "F - test-convert-floating-point-operation/13") - 5101 (check-next-stream-line-equal _test-output-stream " f3 0f 11/copy *(ebp+0xfffffffc) 0x00000005/x32" "F - test-convert-floating-point-operation/14") - 5102 (check-next-stream-line-equal _test-output-stream " f3 0f 58/add %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/15") - 5103 (check-next-stream-line-equal _test-output-stream " f3 0f 58/add *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/16") - 5104 (check-next-stream-line-equal _test-output-stream " f3 0f 5c/subtract %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/17") - 5105 (check-next-stream-line-equal _test-output-stream " f3 0f 5c/subtract *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/18") - 5106 (check-next-stream-line-equal _test-output-stream " f3 0f 59/multiply %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/19") - 5107 (check-next-stream-line-equal _test-output-stream " f3 0f 59/multiply *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/20") - 5108 (check-next-stream-line-equal _test-output-stream " f3 0f 5e/divide %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/21") - 5109 (check-next-stream-line-equal _test-output-stream " f3 0f 5e/divide *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/22") - 5110 (check-next-stream-line-equal _test-output-stream " f3 0f 53/reciprocal %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/23") - 5111 (check-next-stream-line-equal _test-output-stream " f3 0f 53/reciprocal *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/24") - 5112 (check-next-stream-line-equal _test-output-stream " f3 0f 51/square-root %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/25") - 5113 (check-next-stream-line-equal _test-output-stream " f3 0f 51/square-root *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/26") - 5114 (check-next-stream-line-equal _test-output-stream " f3 0f 52/inverse-square-root %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/27") - 5115 (check-next-stream-line-equal _test-output-stream " f3 0f 52/inverse-square-root *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/28") - 5116 (check-next-stream-line-equal _test-output-stream " f3 0f 5f/max %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/29") - 5117 (check-next-stream-line-equal _test-output-stream " f3 0f 5f/max *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/30") - 5118 (check-next-stream-line-equal _test-output-stream " f3 0f 5d/min %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/31") - 5119 (check-next-stream-line-equal _test-output-stream " f3 0f 5d/min *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/32") - 5120 (check-next-stream-line-equal _test-output-stream " 0f 2f/compare %xmm1 0x00000005/x32" "F - test-convert-floating-point-operation/33") - 5121 (check-next-stream-line-equal _test-output-stream " 0f 2f/compare *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/34") - 5122 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 5/x32" "F - test-convert-floating-point-operation/35") - 5123 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-operation/36") - 5124 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-operation/37") - 5125 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-operation/38") - 5126 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-floating-point-operation/39") - 5127 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-operation/40") - 5128 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-floating-point-operation/41") - 5129 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-operation/42") - 5130 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-operation/43") - 5131 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-operation/44") - 5132 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-operation/45") - 5133 # . epilogue - 5134 89/<- %esp 5/r32/ebp - 5135 5d/pop-to-ebp - 5136 c3/return - 5137 - 5138 test-convert-floating-point-dereferenced: - 5139 # . prologue - 5140 55/push-ebp - 5141 89/<- %ebp 4/r32/esp - 5142 # setup - 5143 (clear-stream _test-input-stream) - 5144 (clear-stream $_test-input-buffered-file->buffer) - 5145 (clear-stream _test-output-stream) - 5146 (clear-stream $_test-output-buffered-file->buffer) - 5147 # - 5148 (write _test-input-stream "fn f {\n") - 5149 (write _test-input-stream " var m: float\n") - 5150 (write _test-input-stream " var x/xmm1: float <- copy m\n") - 5151 (write _test-input-stream " var y/eax: (addr float) <- copy 0\n") - 5152 (write _test-input-stream " x <- multiply *y\n") - 5153 (write _test-input-stream "}\n") - 5154 # convert - 5155 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5156 (flush _test-output-buffered-file) - 5157 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5163 # check output - 5164 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-floating-point-dereferenced/0") - 5165 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-dereferenced/1") - 5166 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-dereferenced/2") - 5167 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-dereferenced/3") - 5168 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-dereferenced/4") - 5169 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-floating-point-dereferenced/5") - 5170 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-floating-point-dereferenced/6") - 5171 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-dereferenced/7") - 5172 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-dereferenced/8") - 5173 (check-next-stream-line-equal _test-output-stream " f3 0f 10/copy *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-dereferenced/9") - 5174 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-floating-point-dereferenced/10") - 5175 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-floating-point-dereferenced/11") - 5176 (check-next-stream-line-equal _test-output-stream " f3 0f 59/multiply *eax 0x00000001/x32" "F - test-convert-floating-point-dereferenced/12") - 5177 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-floating-point-dereferenced/13") - 5178 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-dereferenced/14") - 5179 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-dereferenced/15") - 5180 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-floating-point-dereferenced/16") - 5181 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-dereferenced/17") - 5182 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-floating-point-dereferenced/18") - 5183 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-dereferenced/19") - 5184 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-dereferenced/20") - 5185 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-dereferenced/21") - 5186 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-dereferenced/22") - 5187 # . epilogue - 5188 89/<- %esp 5/r32/ebp - 5189 5d/pop-to-ebp - 5190 c3/return - 5191 - 5192 test-convert-length-of-array: - 5193 # . prologue - 5194 55/push-ebp - 5195 89/<- %ebp 4/r32/esp - 5196 # setup - 5197 (clear-stream _test-input-stream) - 5198 (clear-stream $_test-input-buffered-file->buffer) - 5199 (clear-stream _test-output-stream) - 5200 (clear-stream $_test-output-buffered-file->buffer) - 5201 # - 5202 (write _test-input-stream "fn foo a: (addr array int) {\n") - 5203 (write _test-input-stream " var b/eax: (addr array int) <- copy a\n") - 5204 (write _test-input-stream " var c/eax: int <- length b\n") - 5205 (write _test-input-stream "}\n") - 5206 # convert - 5207 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5208 (flush _test-output-buffered-file) - 5209 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5215 # check output - 5216 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array/0") - 5217 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array/1") - 5218 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array/2") - 5219 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array/3") - 5220 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array/4") - 5221 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array/5") - 5222 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array/6") - 5223 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array/7") - 5224 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array/8") - 5225 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array/9") - 5226 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array/10") - 5227 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array/11") - 5228 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array/12") - 5229 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array/13") - 5230 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array/14") - 5231 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array/15") - 5232 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array/16") - 5233 # . epilogue - 5234 89/<- %esp 5/r32/ebp - 5235 5d/pop-to-ebp - 5236 c3/return - 5237 - 5238 # special-case for size(byte) when computing array length - 5239 test-convert-length-of-array-of-bytes: - 5240 # . prologue - 5241 55/push-ebp - 5242 89/<- %ebp 4/r32/esp - 5243 # setup - 5244 (clear-stream _test-input-stream) - 5245 (clear-stream $_test-input-buffered-file->buffer) - 5246 (clear-stream _test-output-stream) - 5247 (clear-stream $_test-output-buffered-file->buffer) - 5248 # - 5249 (write _test-input-stream "fn foo a: (addr array byte) {\n") - 5250 (write _test-input-stream " var b/eax: (addr array byte) <- copy a\n") - 5251 (write _test-input-stream " var c/eax: int <- length b\n") - 5252 (write _test-input-stream "}\n") - 5253 # convert - 5254 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5255 (flush _test-output-buffered-file) - 5256 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5262 # check output - 5263 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-bytes/0") - 5264 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-bytes/1") - 5265 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-bytes/2") - 5266 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-bytes/3") - 5267 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-bytes/4") - 5268 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-bytes/5") - 5269 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-bytes/6") - 5270 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/7") - 5271 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/8") - 5272 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-bytes/9") - 5273 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-bytes/10") - 5274 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-bytes/11") - 5275 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-bytes/12") - 5276 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-bytes/13") - 5277 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-bytes/14") - 5278 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-bytes/15") - 5279 # . epilogue - 5280 89/<- %esp 5/r32/ebp - 5281 5d/pop-to-ebp - 5282 c3/return - 5283 - 5284 test-convert-length-of-array-on-stack: - 5285 # . prologue - 5286 55/push-ebp - 5287 89/<- %ebp 4/r32/esp - 5288 # setup - 5289 (clear-stream _test-input-stream) - 5290 (clear-stream $_test-input-buffered-file->buffer) - 5291 (clear-stream _test-output-stream) - 5292 (clear-stream $_test-output-buffered-file->buffer) - 5293 # - 5294 (write _test-input-stream "fn foo {\n") - 5295 (write _test-input-stream " var a: (array int 3)\n") - 5296 (write _test-input-stream " var b/eax: int <- length a\n") - 5297 (write _test-input-stream "}\n") - 5298 # convert - 5299 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5300 (flush _test-output-buffered-file) - 5301 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5307 # check output - 5308 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-on-stack/0") - 5309 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-on-stack/1") - 5310 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-on-stack/2") - 5311 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-on-stack/3") - 5312 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-on-stack/4") - 5313 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-on-stack/5") - 5314 # define x - 5315 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-length-of-array-on-stack/6") - 5316 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-length-of-array-on-stack/7") - 5317 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-on-stack/8") - 5318 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffff0) 0x00000000/r32" "F - test-convert-length-of-array-on-stack/9") - 5319 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array-on-stack/10") - 5320 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-on-stack/11") - 5321 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-length-of-array-on-stack/12") - 5322 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-on-stack/13") - 5323 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-on-stack/14") - 5324 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-on-stack/15") - 5325 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-on-stack/16") - 5326 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-on-stack/17") - 5327 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-on-stack/18") - 5328 # . epilogue - 5329 89/<- %esp 5/r32/ebp - 5330 5d/pop-to-ebp - 5331 c3/return - 5332 - 5333 test-reg-var-def-with-read-of-same-register: - 5334 # . prologue - 5335 55/push-ebp - 5336 89/<- %ebp 4/r32/esp - 5337 # setup - 5338 (clear-stream _test-input-stream) - 5339 (clear-stream $_test-input-buffered-file->buffer) - 5340 (clear-stream _test-output-stream) - 5341 (clear-stream $_test-output-buffered-file->buffer) - 5342 (clear-stream _test-error-stream) - 5343 (clear-stream $_test-error-buffered-file->buffer) - 5344 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) # bytes of args in call to convert-mu - 5345 68/push 0/imm32 - 5346 68/push 0/imm32 - 5347 89/<- %edx 4/r32/esp - 5348 (tailor-exit-descriptor %edx 0x10) - 5349 # - 5350 (write _test-input-stream "fn foo {\n") - 5351 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 5352 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 5353 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") - 5354 (write _test-input-stream "}\n") - 5355 # convert - 5356 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 5357 # registers except esp could be clobbered at this point (though they shouldn't be) - 5358 # restore ed - 5359 89/<- %edx 4/r32/esp - 5360 (flush _test-output-buffered-file) - 5361 (flush _test-error-buffered-file) - 5362 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5368 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5374 (check-stream-equal _test-error-stream "" "F - test-reg-var-def-with-read-of-same-register: error stream should be empty") - 5375 # check output - 5376 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-reg-var-def-with-read-of-same-register/0") - 5377 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-reg-var-def-with-read-of-same-register/1") - 5378 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-reg-var-def-with-read-of-same-register/2") - 5379 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-reg-var-def-with-read-of-same-register/3") - 5380 (check-next-stream-line-equal _test-output-stream " {" "F - test-reg-var-def-with-read-of-same-register/4") - 5381 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-reg-var-def-with-read-of-same-register/5") - 5382 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-reg-var-def-with-read-of-same-register/6") - 5383 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-reg-var-def-with-read-of-same-register/7") - 5384 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-reg-var-def-with-read-of-same-register/8") - 5385 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-reg-var-def-with-read-of-same-register/9") - 5386 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000002 + 4) 0x00000000/r32" "F - test-reg-var-def-with-read-of-same-register/11") - 5387 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-reg-var-def-with-read-of-same-register/13") - 5388 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-reg-var-def-with-read-of-same-register/14") - 5389 (check-next-stream-line-equal _test-output-stream " }" "F - test-reg-var-def-with-read-of-same-register/15") - 5390 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-reg-var-def-with-read-of-same-register/16") - 5391 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-reg-var-def-with-read-of-same-register/17") - 5392 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-reg-var-def-with-read-of-same-register/18") - 5393 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-reg-var-def-with-read-of-same-register/19") - 5394 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-reg-var-def-with-read-of-same-register/20") - 5395 # don't restore from ebp - 5396 81 0/subop/add %esp 8/imm32 - 5397 # . epilogue - 5398 5d/pop-to-ebp - 5399 c3/return - 5400 - 5401 test-convert-index-into-array: - 5402 # . prologue - 5403 55/push-ebp - 5404 89/<- %ebp 4/r32/esp - 5405 # setup - 5406 (clear-stream _test-input-stream) - 5407 (clear-stream $_test-input-buffered-file->buffer) - 5408 (clear-stream _test-output-stream) - 5409 (clear-stream $_test-output-buffered-file->buffer) - 5410 # - 5411 (write _test-input-stream "fn foo {\n") - 5412 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 5413 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 5414 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") - 5415 (write _test-input-stream "}\n") - 5416 # convert - 5417 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5418 (flush _test-output-buffered-file) - 5419 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5425 # check output - 5426 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array/0") - 5427 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array/1") - 5428 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array/2") - 5429 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array/3") - 5430 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array/4") - 5431 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array/5") - 5432 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array/6") - 5433 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array/7") - 5434 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array/8") - 5435 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array/9") - 5436 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000002 + 4) 0x00000000/r32" "F - test-convert-index-into-array/10") - 5437 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array/11") - 5438 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array/12") - 5439 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array/13") - 5440 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array/14") - 5441 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array/15") - 5442 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array/16") - 5443 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array/17") - 5444 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array/18") - 5445 # . epilogue - 5446 89/<- %esp 5/r32/ebp - 5447 5d/pop-to-ebp - 5448 c3/return - 5449 - 5450 test-convert-index-into-array-of-bytes: - 5451 # . prologue - 5452 55/push-ebp - 5453 89/<- %ebp 4/r32/esp - 5454 # setup - 5455 (clear-stream _test-input-stream) - 5456 (clear-stream $_test-input-buffered-file->buffer) - 5457 (clear-stream _test-output-stream) - 5458 (clear-stream $_test-output-buffered-file->buffer) - 5459 # - 5460 (write _test-input-stream "fn foo {\n") - 5461 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") - 5462 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 5463 (write _test-input-stream " var x/eax: (addr byte) <- index arr, idx\n") - 5464 (write _test-input-stream "}\n") - 5465 # convert - 5466 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5467 (flush _test-output-buffered-file) - 5468 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5474 # check output - 5475 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes/0") - 5476 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes/1") - 5477 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes/2") - 5478 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes/3") - 5479 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes/4") - 5480 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes/5") - 5481 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes/6") - 5482 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes/7") - 5483 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes/8") - 5484 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes/9") - 5485 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000000 + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes/11") - 5486 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes/13") - 5487 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes/14") - 5488 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes/15") - 5489 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes/16") - 5490 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes/17") - 5491 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes/18") - 5492 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes/19") - 5493 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes/20") - 5494 # . epilogue - 5495 89/<- %esp 5/r32/ebp - 5496 5d/pop-to-ebp - 5497 c3/return - 5498 - 5499 test-convert-index-into-array-with-literal: - 5500 # . prologue - 5501 55/push-ebp - 5502 89/<- %ebp 4/r32/esp - 5503 # setup - 5504 (clear-stream _test-input-stream) - 5505 (clear-stream $_test-input-buffered-file->buffer) - 5506 (clear-stream _test-output-stream) - 5507 (clear-stream $_test-output-buffered-file->buffer) - 5508 # - 5509 (write _test-input-stream "fn foo {\n") - 5510 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 5511 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n") - 5512 (write _test-input-stream "}\n") - 5513 # convert - 5514 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5515 (flush _test-output-buffered-file) - 5516 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5522 # check output - 5523 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-with-literal/0") - 5524 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-with-literal/1") - 5525 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-with-literal/2") - 5526 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-with-literal/3") - 5527 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-with-literal/4") - 5528 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-with-literal/5") - 5529 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-with-literal/6") - 5530 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-with-literal/7") - 5531 # 2 * 4 bytes/elem + 4 bytes for size = offset 12 - 5532 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x0000000c) 0x00000000/r32" "F - test-convert-index-into-array-with-literal/8") - 5533 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-with-literal/9") - 5534 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-with-literal/10") - 5535 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-with-literal/11") - 5536 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-with-literal/12") - 5537 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-with-literal/13") - 5538 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-with-literal/14") - 5539 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-with-literal/15") - 5540 # . epilogue - 5541 89/<- %esp 5/r32/ebp - 5542 5d/pop-to-ebp - 5543 c3/return - 5544 - 5545 test-convert-index-into-array-of-bytes-with-literal: - 5546 # . prologue - 5547 55/push-ebp - 5548 89/<- %ebp 4/r32/esp - 5549 # setup - 5550 (clear-stream _test-input-stream) - 5551 (clear-stream $_test-input-buffered-file->buffer) - 5552 (clear-stream _test-output-stream) - 5553 (clear-stream $_test-output-buffered-file->buffer) - 5554 # - 5555 (write _test-input-stream "fn foo {\n") - 5556 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") - 5557 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n") - 5558 (write _test-input-stream "}\n") - 5559 # convert - 5560 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5561 (flush _test-output-buffered-file) - 5562 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5568 # check output - 5569 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-with-literal/0") - 5570 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-with-literal/1") - 5571 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/2") - 5572 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-with-literal/3") - 5573 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-with-literal/4") - 5574 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-with-literal/5") - 5575 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-with-literal/6") - 5576 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-with-literal/7") - 5577 # 2 * 1 byte/elem + 4 bytes for size = offset 6 - 5578 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000006) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-with-literal/8") - 5579 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-with-literal/9") - 5580 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-with-literal/10") - 5581 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-with-literal/11") - 5582 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-with-literal/12") - 5583 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-with-literal/13") - 5584 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/14") - 5585 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-with-literal/15") - 5586 # . epilogue - 5587 89/<- %esp 5/r32/ebp - 5588 5d/pop-to-ebp - 5589 c3/return - 5590 - 5591 test-convert-index-into-array-on-stack: - 5592 # . prologue - 5593 55/push-ebp - 5594 89/<- %ebp 4/r32/esp - 5595 # setup - 5596 (clear-stream _test-input-stream) - 5597 (clear-stream $_test-input-buffered-file->buffer) - 5598 (clear-stream _test-output-stream) - 5599 (clear-stream $_test-output-buffered-file->buffer) - 5600 # - 5601 (write _test-input-stream "fn foo {\n") - 5602 (write _test-input-stream " var arr: (array int 3)\n") - 5603 (write _test-input-stream " var idx/eax: int <- copy 2\n") - 5604 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") - 5605 (write _test-input-stream "}\n") - 5606 # convert - 5607 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5608 (flush _test-output-buffered-file) - 5609 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5615 # check output - 5616 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack/0") - 5617 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack/1") - 5618 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack/2") - 5619 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack/3") - 5620 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack/4") - 5621 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack/5") - 5622 # var arr - 5623 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack/6") - 5624 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack/7") - 5625 # var idx - 5626 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack/8") - 5627 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 2/imm32" "F - test-convert-index-into-array-on-stack/9") - 5628 # var x is at (ebp-0x10) + idx<<2 + 4 = ebp + idx<<2 - 0xc - 5629 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + eax<<0x00000002 + 0xfffffff4) 0x00000000/r32" "F - test-convert-index-into-array-on-stack/10") - 5630 # reclaim idx - 5631 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack/11") - 5632 # reclaim arr - 5633 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack/12") - 5634 # - 5635 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack/13") - 5636 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack/14") - 5637 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack/15") - 5638 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack/16") - 5639 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack/17") - 5640 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack/18") - 5641 # . epilogue - 5642 89/<- %esp 5/r32/ebp - 5643 5d/pop-to-ebp - 5644 c3/return - 5645 - 5646 test-convert-index-into-array-on-stack-with-literal: - 5647 # . prologue - 5648 55/push-ebp - 5649 89/<- %ebp 4/r32/esp - 5650 # setup - 5651 (clear-stream _test-input-stream) - 5652 (clear-stream $_test-input-buffered-file->buffer) - 5653 (clear-stream _test-output-stream) - 5654 (clear-stream $_test-output-buffered-file->buffer) - 5655 # - 5656 (write _test-input-stream "fn foo {\n") - 5657 (write _test-input-stream " var arr: (array int 3)\n") - 5658 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n") - 5659 (write _test-input-stream "}\n") - 5660 # convert - 5661 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5662 (flush _test-output-buffered-file) - 5663 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5669 # check output - 5670 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack-with-literal/0") - 5671 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack-with-literal/1") - 5672 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack-with-literal/2") - 5673 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack-with-literal/3") - 5674 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack-with-literal/4") - 5675 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack-with-literal/5") - 5676 # var arr - 5677 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack-with-literal/6") - 5678 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack-with-literal/7") - 5679 # var x - 5680 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack-with-literal/8") - 5681 # x is at (ebp-0x10) + 4 + 2*4 = ebp-4 - 5682 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xfffffffc) 0x00000000/r32" "F - test-convert-index-into-array-on-stack-with-literal/9") - 5683 # reclaim x - 5684 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack-with-literal/10") - 5685 # reclaim arr - 5686 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack-with-literal/11") - 5687 # - 5688 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack-with-literal/12") - 5689 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack-with-literal/13") - 5690 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack-with-literal/14") - 5691 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack-with-literal/15") - 5692 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack-with-literal/16") - 5693 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack-with-literal/17") - 5694 # . epilogue - 5695 89/<- %esp 5/r32/ebp - 5696 5d/pop-to-ebp - 5697 c3/return - 5698 - 5699 test-convert-index-into-array-of-bytes-on-stack-with-literal: - 5700 # . prologue - 5701 55/push-ebp - 5702 89/<- %ebp 4/r32/esp - 5703 # setup - 5704 (clear-stream _test-input-stream) - 5705 (clear-stream $_test-input-buffered-file->buffer) - 5706 (clear-stream _test-output-stream) - 5707 (clear-stream $_test-output-buffered-file->buffer) - 5708 # - 5709 (write _test-input-stream "fn foo {\n") - 5710 (write _test-input-stream " var arr: (array byte 3)\n") - 5711 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n") - 5712 (write _test-input-stream "}\n") - 5713 # convert - 5714 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5715 (flush _test-output-buffered-file) - 5716 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5722 # check output - 5723 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/0") - 5724 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/1") - 5725 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/2") - 5726 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/3") - 5727 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/4") - 5728 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/5") - 5729 # var arr - 5730 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/6") - 5731 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/7") - 5732 # var x - 5733 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/8") - 5734 # x is at (ebp-7) + 4 + 2 = ebp-1 - 5735 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xffffffff) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/9") - 5736 # reclaim x - 5737 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/10") - 5738 # reclaim arr - 5739 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/11") - 5740 # - 5741 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/12") - 5742 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/13") - 5743 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/14") - 5744 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/15") - 5745 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/16") - 5746 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/17") - 5747 # . epilogue - 5748 89/<- %esp 5/r32/ebp - 5749 5d/pop-to-ebp - 5750 c3/return - 5751 - 5752 test-convert-index-into-array-using-offset: - 5753 # . prologue - 5754 55/push-ebp - 5755 89/<- %ebp 4/r32/esp - 5756 # setup - 5757 (clear-stream _test-input-stream) - 5758 (clear-stream $_test-input-buffered-file->buffer) - 5759 (clear-stream _test-output-stream) - 5760 (clear-stream $_test-output-buffered-file->buffer) - 5761 # - 5762 (write _test-input-stream "fn foo {\n") - 5763 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 5764 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 5765 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n") - 5766 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n") - 5767 (write _test-input-stream "}\n") - 5768 # convert - 5769 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5770 (flush _test-output-buffered-file) - 5771 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5777 # check output - 5778 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset/0") - 5779 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset/1") - 5780 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset/2") - 5781 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset/3") - 5782 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset/4") - 5783 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset/5") - 5784 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset/6") - 5785 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset/7") - 5786 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset/8") - 5787 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-using-offset/9") - 5788 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset/10") - 5789 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset/11") - 5790 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset/12") - 5791 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset/13") - 5792 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset/14") - 5793 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset/15") - 5794 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset/16") - 5795 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset/17") - 5796 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset/18") - 5797 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset/19") - 5798 # . epilogue - 5799 89/<- %esp 5/r32/ebp - 5800 5d/pop-to-ebp - 5801 c3/return - 5802 - 5803 test-convert-index-into-array-of-bytes-using-offset: - 5804 # . prologue - 5805 55/push-ebp - 5806 89/<- %ebp 4/r32/esp - 5807 # setup - 5808 (clear-stream _test-input-stream) - 5809 (clear-stream $_test-input-buffered-file->buffer) - 5810 (clear-stream _test-output-stream) - 5811 (clear-stream $_test-output-buffered-file->buffer) - 5812 # - 5813 (write _test-input-stream "fn foo {\n") - 5814 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") - 5815 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 5816 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n") - 5817 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n") - 5818 (write _test-input-stream "}\n") - 5819 # convert - 5820 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5821 (flush _test-output-buffered-file) - 5822 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5828 # check output - 5829 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset/0") - 5830 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset/1") - 5831 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/2") - 5832 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset/3") - 5833 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset/4") - 5834 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset/5") - 5835 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset/6") - 5836 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/7") - 5837 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/8") - 5838 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/9") - 5839 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset/10") - 5840 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset/11") - 5841 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/12") - 5842 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset/13") - 5843 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset/14") - 5844 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset/15") - 5845 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset/16") - 5846 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset/17") - 5847 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/18") - 5848 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset/19") - 5849 # . epilogue - 5850 89/<- %esp 5/r32/ebp - 5851 5d/pop-to-ebp - 5852 c3/return - 5853 - 5854 test-convert-index-into-array-using-offset-on-stack: - 5855 # . prologue - 5856 55/push-ebp - 5857 89/<- %ebp 4/r32/esp - 5858 # setup - 5859 (clear-stream _test-input-stream) - 5860 (clear-stream $_test-input-buffered-file->buffer) - 5861 (clear-stream _test-output-stream) - 5862 (clear-stream $_test-output-buffered-file->buffer) - 5863 # - 5864 (write _test-input-stream "fn foo {\n") - 5865 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") - 5866 (write _test-input-stream " var idx: int\n") - 5867 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n") - 5868 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n") - 5869 (write _test-input-stream "}\n") - 5870 # convert - 5871 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5872 (flush _test-output-buffered-file) - 5873 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5879 # check output - 5880 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset-on-stack/0") - 5881 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset-on-stack/1") - 5882 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset-on-stack/2") - 5883 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset-on-stack/3") - 5884 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset-on-stack/4") - 5885 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset-on-stack/5") - 5886 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset-on-stack/6") - 5887 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/7") - 5888 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/8") - 5889 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset-on-stack/9") - 5890 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset-on-stack/10") - 5891 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset-on-stack/11") - 5892 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset-on-stack/12") - 5893 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-using-offset-on-stack/13") - 5894 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset-on-stack/14") - 5895 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset-on-stack/15") - 5896 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset-on-stack/16") - 5897 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset-on-stack/17") - 5898 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset-on-stack/18") - 5899 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset-on-stack/19") - 5900 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset-on-stack/20") - 5901 # . epilogue - 5902 89/<- %esp 5/r32/ebp - 5903 5d/pop-to-ebp - 5904 c3/return - 5905 - 5906 test-convert-index-into-array-of-bytes-using-offset-on-stack: - 5907 # . prologue - 5908 55/push-ebp - 5909 89/<- %ebp 4/r32/esp - 5910 # setup - 5911 (clear-stream _test-input-stream) - 5912 (clear-stream $_test-input-buffered-file->buffer) - 5913 (clear-stream _test-output-stream) - 5914 (clear-stream $_test-output-buffered-file->buffer) - 5915 # - 5916 (write _test-input-stream "fn foo {\n") - 5917 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") - 5918 (write _test-input-stream " var idx: int\n") - 5919 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n") - 5920 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n") - 5921 (write _test-input-stream "}\n") - 5922 # convert - 5923 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5924 (flush _test-output-buffered-file) - 5925 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5931 # check output - 5932 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/0") - 5933 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/1") - 5934 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/2") - 5935 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/3") - 5936 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/4") - 5937 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/5") - 5938 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/6") - 5939 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/7") - 5940 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/8") - 5941 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/9") - 5942 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/10") - 5943 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/11") - 5944 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/12") - 5945 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/13") - 5946 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/14") - 5947 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/15") - 5948 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/16") - 5949 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/17") - 5950 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/18") - 5951 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/19") - 5952 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/20") - 5953 # . epilogue - 5954 89/<- %esp 5/r32/ebp - 5955 5d/pop-to-ebp - 5956 c3/return - 5957 - 5958 test-convert-function-and-type-definition: - 5959 # . prologue - 5960 55/push-ebp - 5961 89/<- %ebp 4/r32/esp - 5962 # setup - 5963 (clear-stream _test-input-stream) - 5964 (clear-stream $_test-input-buffered-file->buffer) - 5965 (clear-stream _test-output-stream) - 5966 (clear-stream $_test-output-buffered-file->buffer) - 5967 # - 5968 (write _test-input-stream "fn foo a: (addr t) {\n") - 5969 (write _test-input-stream " var _a/eax: (addr t) <- copy a\n") - 5970 (write _test-input-stream " var b/ecx: (addr int) <- get _a, x\n") - 5971 (write _test-input-stream " var c/ecx: (addr int) <- get _a, y\n") - 5972 (write _test-input-stream "}\n") - 5973 (write _test-input-stream "type t {\n") - 5974 (write _test-input-stream " x: int\n") - 5975 (write _test-input-stream " y: int\n") - 5976 (write _test-input-stream "}\n") - 5977 # convert - 5978 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 5979 (flush _test-output-buffered-file) - 5980 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 5986 # check output - 5987 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-and-type-definition/0") - 5988 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-and-type-definition/1") - 5989 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-and-type-definition/2") - 5990 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-and-type-definition/3") - 5991 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-and-type-definition/4") - 5992 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-and-type-definition/5") - 5993 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-and-type-definition/6") - 5994 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-and-type-definition/7") - 5995 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-and-type-definition/8") - 5996 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000000) 0x00000001/r32" "F - test-convert-function-and-type-definition/9") - 5997 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000004) 0x00000001/r32" "F - test-convert-function-and-type-definition/11") - 5998 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-and-type-definition/13") - 5999 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-and-type-definition/14") - 6000 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-and-type-definition/15") - 6001 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-and-type-definition/16") - 6002 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-and-type-definition/17") - 6003 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-and-type-definition/18") - 6004 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-and-type-definition/19") - 6005 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-and-type-definition/20") - 6006 # . epilogue - 6007 89/<- %esp 5/r32/ebp - 6008 5d/pop-to-ebp - 6009 c3/return - 6010 - 6011 test-type-definition-with-array: - 6012 # . prologue - 6013 55/push-ebp - 6014 89/<- %ebp 4/r32/esp - 6015 # setup - 6016 (clear-stream _test-input-stream) - 6017 (clear-stream $_test-input-buffered-file->buffer) - 6018 (clear-stream _test-output-stream) - 6019 (clear-stream $_test-output-buffered-file->buffer) - 6020 (clear-stream _test-error-stream) - 6021 (clear-stream $_test-error-buffered-file->buffer) - 6022 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6023 68/push 0/imm32 - 6024 68/push 0/imm32 - 6025 89/<- %edx 4/r32/esp - 6026 (tailor-exit-descriptor %edx 0x10) + 4203 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-shadow-name-2/0") + 4204 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-shadow-name-2/1") + 4205 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-shadow-name-2/2") + 4206 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-shadow-name-2/3") + 4207 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/4") + 4208 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-shadow-name-2/5") + 4209 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/6") + 4210 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-shadow-name-2/7") + 4211 (check-next-stream-line-equal _test-output-stream " {" "F - test-shadow-name-2/8") + 4212 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-shadow-name-2/9") + 4213 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-shadow-name-2/10") + 4214 (check-next-stream-line-equal _test-output-stream " ba/copy-to-edx 4/imm32" "F - test-shadow-name-2/11") + 4215 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-shadow-name-2/12") + 4216 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 5/imm32" "F - test-shadow-name-2/13") + 4217 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/14") + 4218 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-shadow-name-2/15") + 4219 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/16") + 4220 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-shadow-name-2/17") + 4221 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-shadow-name-2/18") + 4222 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-shadow-name-2/19") + 4223 (check-next-stream-line-equal _test-output-stream " }" "F - test-shadow-name-2/20") + 4224 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-shadow-name-2/21") + 4225 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-shadow-name-2/22") + 4226 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-shadow-name-2/23") + 4227 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-shadow-name-2/24") + 4228 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-shadow-name-2/25") + 4229 # . epilogue + 4230 89/<- %esp 5/r32/ebp + 4231 5d/pop-to-ebp + 4232 c3/return + 4233 + 4234 test-do-not-spill-same-register-in-block: + 4235 # . prologue + 4236 55/push-ebp + 4237 89/<- %ebp 4/r32/esp + 4238 # setup + 4239 (clear-stream _test-input-stream) + 4240 (clear-stream $_test-input-buffered-file->buffer) + 4241 (clear-stream _test-output-stream) + 4242 (clear-stream $_test-output-buffered-file->buffer) + 4243 # + 4244 (write _test-input-stream "fn foo {\n") + 4245 (write _test-input-stream " var x/ecx: int <- copy 3\n") + 4246 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 4247 (write _test-input-stream " y <- increment\n") + 4248 (write _test-input-stream "}\n") + 4249 # convert + 4250 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4251 (flush _test-output-buffered-file) + 4252 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4258 # check output + 4259 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-do-not-spill-same-register-in-block/0") + 4260 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-do-not-spill-same-register-in-block/1") + 4261 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-do-not-spill-same-register-in-block/2") + 4262 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-do-not-spill-same-register-in-block/3") + 4263 (check-next-stream-line-equal _test-output-stream " {" "F - test-do-not-spill-same-register-in-block/4") + 4264 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-do-not-spill-same-register-in-block/5") + 4265 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-do-not-spill-same-register-in-block/6") + 4266 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-do-not-spill-same-register-in-block/7") + 4267 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-do-not-spill-same-register-in-block/8") + 4268 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-do-not-spill-same-register-in-block/9") + 4269 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-do-not-spill-same-register-in-block/10") + 4270 (check-next-stream-line-equal _test-output-stream " }" "F - test-do-not-spill-same-register-in-block/11") + 4271 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-do-not-spill-same-register-in-block/12") + 4272 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-do-not-spill-same-register-in-block/13") + 4273 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-do-not-spill-same-register-in-block/14") + 4274 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-do-not-spill-same-register-in-block/15") + 4275 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-do-not-spill-same-register-in-block/16") + 4276 # . epilogue + 4277 89/<- %esp 5/r32/ebp + 4278 5d/pop-to-ebp + 4279 c3/return + 4280 + 4281 test-spill-different-register-in-block: + 4282 # . prologue + 4283 55/push-ebp + 4284 89/<- %ebp 4/r32/esp + 4285 # setup + 4286 (clear-stream _test-input-stream) + 4287 (clear-stream $_test-input-buffered-file->buffer) + 4288 (clear-stream _test-output-stream) + 4289 (clear-stream $_test-output-buffered-file->buffer) + 4290 # + 4291 (write _test-input-stream "fn foo {\n") + 4292 (write _test-input-stream " var x/eax: int <- copy 3\n") + 4293 (write _test-input-stream " var y/ecx: int <- copy 4\n") + 4294 (write _test-input-stream " y <- increment\n") + 4295 (write _test-input-stream "}\n") + 4296 # convert + 4297 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4298 (flush _test-output-buffered-file) + 4299 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4305 # check output + 4306 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-spill-different-register-in-block/0") + 4307 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-spill-different-register-in-block/1") + 4308 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-spill-different-register-in-block/2") + 4309 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-spill-different-register-in-block/3") + 4310 (check-next-stream-line-equal _test-output-stream " {" "F - test-spill-different-register-in-block/4") + 4311 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-spill-different-register-in-block/5") + 4312 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-spill-different-register-in-block/6") + 4313 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-spill-different-register-in-block/7") + 4314 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-spill-different-register-in-block/8") + 4315 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-spill-different-register-in-block/9") + 4316 (check-next-stream-line-equal _test-output-stream " 41/increment-ecx" "F - test-spill-different-register-in-block/10") + 4317 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-spill-different-register-in-block/11") + 4318 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-spill-different-register-in-block/12") + 4319 (check-next-stream-line-equal _test-output-stream " }" "F - test-spill-different-register-in-block/13") + 4320 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-spill-different-register-in-block/14") + 4321 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-spill-different-register-in-block/15") + 4322 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-spill-different-register-in-block/16") + 4323 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-spill-different-register-in-block/17") + 4324 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-spill-different-register-in-block/18") + 4325 # . epilogue + 4326 89/<- %esp 5/r32/ebp + 4327 5d/pop-to-ebp + 4328 c3/return + 4329 + 4330 test-convert-function-with-branches-in-block: + 4331 # . prologue + 4332 55/push-ebp + 4333 89/<- %ebp 4/r32/esp + 4334 # setup + 4335 (clear-stream _test-input-stream) + 4336 (clear-stream $_test-input-buffered-file->buffer) + 4337 (clear-stream _test-output-stream) + 4338 (clear-stream $_test-output-buffered-file->buffer) + 4339 # + 4340 (write _test-input-stream "fn foo x: int {\n") + 4341 (write _test-input-stream " {\n") + 4342 (write _test-input-stream " break-if->=\n") + 4343 (write _test-input-stream " loop-if-addr<\n") + 4344 (write _test-input-stream " increment x\n") + 4345 (write _test-input-stream " loop\n") + 4346 (write _test-input-stream " }\n") + 4347 (write _test-input-stream "}\n") + 4348 # convert + 4349 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4350 (flush _test-output-buffered-file) + 4351 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4357 # check output + 4358 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0") + 4359 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1") + 4360 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-block/2") + 4361 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-block/3") + 4362 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/4") + 4363 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-block/5") + 4364 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/6") + 4365 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-in-block/7") + 4366 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/8") + 4367 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-block/9") + 4368 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-in-block/10") + 4369 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/11") + 4370 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/12") + 4371 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-block/13") + 4372 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-branches-in-block/14") + 4373 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/15") + 4374 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-block/16") + 4375 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-block/17") + 4376 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/18") + 4377 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-in-block/19") + 4378 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/20") + 4379 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-block/21") + 4380 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-block/22") + 4381 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-block/23") + 4382 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-block/24") + 4383 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-block/25") + 4384 # . epilogue + 4385 89/<- %esp 5/r32/ebp + 4386 5d/pop-to-ebp + 4387 c3/return + 4388 + 4389 test-convert-function-with-branches-in-block-2: + 4390 # . prologue + 4391 55/push-ebp + 4392 89/<- %ebp 4/r32/esp + 4393 # setup + 4394 (clear-stream _test-input-stream) + 4395 (clear-stream $_test-input-buffered-file->buffer) + 4396 (clear-stream _test-output-stream) + 4397 (clear-stream $_test-output-buffered-file->buffer) + 4398 # + 4399 (write _test-input-stream "fn foo x: int {\n") + 4400 (write _test-input-stream " {\n") + 4401 (write _test-input-stream " break-if->=\n") + 4402 (write _test-input-stream " loop-if-float<\n") + 4403 (write _test-input-stream " increment x\n") + 4404 (write _test-input-stream " loop\n") + 4405 (write _test-input-stream " }\n") + 4406 (write _test-input-stream "}\n") + 4407 # convert + 4408 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4409 (flush _test-output-buffered-file) + 4410 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4416 # check output + 4417 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-block/0") + 4418 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-block/1") + 4419 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-block/2") + 4420 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-block/3") + 4421 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/4") + 4422 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-block/5") + 4423 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/6") + 4424 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-in-block/7") + 4425 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/8") + 4426 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-block/9") + 4427 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-in-block/10") + 4428 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/11") + 4429 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-block/12") + 4430 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-block/13") + 4431 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-branches-in-block/14") + 4432 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/15") + 4433 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-block/16") + 4434 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-block/17") + 4435 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/18") + 4436 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-in-block/19") + 4437 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-block/20") + 4438 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-block/21") + 4439 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-block/22") + 4440 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-block/23") + 4441 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-block/24") + 4442 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-block/25") + 4443 # . epilogue + 4444 89/<- %esp 5/r32/ebp + 4445 5d/pop-to-ebp + 4446 c3/return + 4447 + 4448 test-convert-function-with-branches-in-named-block: + 4449 # . prologue + 4450 55/push-ebp + 4451 89/<- %ebp 4/r32/esp + 4452 # setup + 4453 (clear-stream _test-input-stream) + 4454 (clear-stream $_test-input-buffered-file->buffer) + 4455 (clear-stream _test-output-stream) + 4456 (clear-stream $_test-output-buffered-file->buffer) + 4457 # + 4458 (write _test-input-stream "fn foo x: int {\n") + 4459 (write _test-input-stream " $bar: {\n") + 4460 (write _test-input-stream " break-if->= $bar\n") + 4461 (write _test-input-stream " loop-if-addr< $bar\n") + 4462 (write _test-input-stream " increment x\n") + 4463 (write _test-input-stream " loop\n") + 4464 (write _test-input-stream " }\n") + 4465 (write _test-input-stream "}\n") + 4466 # convert + 4467 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4468 (flush _test-output-buffered-file) + 4469 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4475 # check output + 4476 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-in-named-block/0") + 4477 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-in-named-block/1") + 4478 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-in-named-block/2") + 4479 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-in-named-block/3") + 4480 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/4") + 4481 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-in-named-block/5") + 4482 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/6") + 4483 (check-next-stream-line-equal _test-output-stream "$bar:loop:" "F - test-convert-function-with-branches-in-named-block/7") + 4484 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/8") + 4485 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-in-named-block/9") + 4486 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:break/disp32" "F - test-convert-function-with-branches-in-named-block/10") + 4487 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/11") + 4488 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-in-named-block/12") + 4489 (check-next-stream-line-equal _test-output-stream " 0f 83/jump-if-addr>= break/disp32" "F - test-convert-function-with-branches-in-named-block/13") + 4490 (check-next-stream-line-equal _test-output-stream " e9/jump $bar:loop/disp32" "F - test-convert-function-with-branches-in-named-block/14") + 4491 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/15") + 4492 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0x00000008)" "F - test-convert-function-with-branches-in-named-block/16") + 4493 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-in-named-block/17") + 4494 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/18") + 4495 (check-next-stream-line-equal _test-output-stream "$bar:break:" "F - test-convert-function-with-branches-in-named-block/19") + 4496 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-in-named-block/20") + 4497 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-in-named-block/21") + 4498 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-in-named-block/22") + 4499 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-in-named-block/23") + 4500 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-in-named-block/24") + 4501 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-in-named-block/25") + 4502 # . epilogue + 4503 89/<- %esp 5/r32/ebp + 4504 5d/pop-to-ebp + 4505 c3/return + 4506 + 4507 test-convert-function-with-var-in-nested-block: + 4508 # . prologue + 4509 55/push-ebp + 4510 89/<- %ebp 4/r32/esp + 4511 # setup + 4512 (clear-stream _test-input-stream) + 4513 (clear-stream $_test-input-buffered-file->buffer) + 4514 (clear-stream _test-output-stream) + 4515 (clear-stream $_test-output-buffered-file->buffer) + 4516 # + 4517 (write _test-input-stream "fn foo x: int {\n") + 4518 (write _test-input-stream " {\n") + 4519 (write _test-input-stream " {\n") + 4520 (write _test-input-stream " var x: int\n") + 4521 (write _test-input-stream " increment x\n") + 4522 (write _test-input-stream " }\n") + 4523 (write _test-input-stream " }\n") + 4524 (write _test-input-stream "}\n") + 4525 # convert + 4526 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4527 (flush _test-output-buffered-file) + 4528 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4534 # check output + 4535 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-var-in-nested-block/0") + 4536 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-var-in-nested-block/1") + 4537 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-var-in-nested-block/2") + 4538 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-var-in-nested-block/3") + 4539 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/4") + 4540 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-var-in-nested-block/5") + 4541 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/6") + 4542 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-var-in-nested-block/7") + 4543 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-var-in-nested-block/8") + 4544 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-var-in-nested-block/9") + 4545 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-var-in-nested-block/10") + 4546 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-var-in-nested-block/11") + 4547 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-var-in-nested-block/12") + 4548 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/13") + 4549 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-var-in-nested-block/14") + 4550 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/15") + 4551 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-var-in-nested-block/16") + 4552 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-var-in-nested-block/17") + 4553 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-var-in-nested-block/18") + 4554 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-var-in-nested-block/19") + 4555 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-var-in-nested-block/20") + 4556 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-var-in-nested-block/21") + 4557 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-var-in-nested-block/22") + 4558 # . epilogue + 4559 89/<- %esp 5/r32/ebp + 4560 5d/pop-to-ebp + 4561 c3/return + 4562 + 4563 test-convert-function-with-multiple-vars-in-nested-blocks: + 4564 # . prologue + 4565 55/push-ebp + 4566 89/<- %ebp 4/r32/esp + 4567 # setup + 4568 (clear-stream _test-input-stream) + 4569 (clear-stream $_test-input-buffered-file->buffer) + 4570 (clear-stream _test-output-stream) + 4571 (clear-stream $_test-output-buffered-file->buffer) + 4572 # + 4573 (write _test-input-stream "fn foo x: int {\n") + 4574 (write _test-input-stream " {\n") + 4575 (write _test-input-stream " var x/eax: int <- copy 0\n") + 4576 (write _test-input-stream " {\n") + 4577 (write _test-input-stream " var y: int\n") + 4578 (write _test-input-stream " x <- add y\n") + 4579 (write _test-input-stream " }\n") + 4580 (write _test-input-stream " }\n") + 4581 (write _test-input-stream "}\n") + 4582 # convert + 4583 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4584 (flush _test-output-buffered-file) + 4585 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4591 # check output + 4592 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/0") + 4593 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/1") + 4594 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/2") + 4595 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/3") + 4596 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/4") + 4597 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/5") + 4598 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/6") + 4599 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/7") + 4600 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/8") + 4601 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/9") + 4602 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-multiple-vars-in-nested-blocks/10") + 4603 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/11") + 4604 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/12") + 4605 (check-next-stream-line-equal _test-output-stream " 03/add *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/13") + 4606 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-multiple-vars-in-nested-blocks/14") + 4607 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/15") + 4608 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/16") + 4609 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-multiple-vars-in-nested-blocks/17") + 4610 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/18") + 4611 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/19") + 4612 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-multiple-vars-in-nested-blocks/20") + 4613 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-multiple-vars-in-nested-blocks/21") + 4614 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-multiple-vars-in-nested-blocks/22") + 4615 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/23") + 4616 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-multiple-vars-in-nested-blocks/24") + 4617 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-multiple-vars-in-nested-blocks/25") + 4618 # . epilogue + 4619 89/<- %esp 5/r32/ebp + 4620 5d/pop-to-ebp + 4621 c3/return + 4622 + 4623 test-convert-function-with-branches-and-local-vars: + 4624 # A conditional 'break' after a 'var' in a block is converted into a + 4625 # nested block that performs all necessary cleanup before jumping. This + 4626 # results in some ugly code duplication. + 4627 # . prologue + 4628 55/push-ebp + 4629 89/<- %ebp 4/r32/esp + 4630 # setup + 4631 (clear-stream _test-input-stream) + 4632 (clear-stream $_test-input-buffered-file->buffer) + 4633 (clear-stream _test-output-stream) + 4634 (clear-stream $_test-output-buffered-file->buffer) + 4635 # + 4636 (write _test-input-stream "fn foo {\n") + 4637 (write _test-input-stream " {\n") + 4638 (write _test-input-stream " var x: int\n") + 4639 (write _test-input-stream " break-if->=\n") + 4640 (write _test-input-stream " increment x\n") + 4641 (write _test-input-stream " }\n") + 4642 (write _test-input-stream "}\n") + 4643 # convert + 4644 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4645 (flush _test-output-buffered-file) + 4646 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4652 # check output + 4653 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-local-vars/0") + 4654 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-local-vars/1") + 4655 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-local-vars/2") + 4656 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-local-vars/3") + 4657 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/4") + 4658 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-local-vars/5") + 4659 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/6") + 4660 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-local-vars/7") + 4661 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-local-vars/8") + 4662 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-local-vars/9") + 4663 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-local-vars/10") + 4664 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/11") + 4665 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-local-vars/12") + 4666 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/13") + 4667 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-local-vars/14") + 4668 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-local-vars/15") + 4669 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/16") + 4670 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-local-vars/17") + 4671 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-local-vars/18") + 4672 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-local-vars/19") + 4673 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-local-vars/20") + 4674 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-local-vars/21") + 4675 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-local-vars/22") + 4676 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-local-vars/23") + 4677 # . epilogue + 4678 89/<- %esp 5/r32/ebp + 4679 5d/pop-to-ebp + 4680 c3/return + 4681 + 4682 test-convert-function-with-conditional-loops-and-local-vars: + 4683 # A conditional 'loop' after a 'var' in a block is converted into a nested + 4684 # block that performs all necessary cleanup before jumping. This results + 4685 # in some ugly code duplication. + 4686 # . prologue + 4687 55/push-ebp + 4688 89/<- %ebp 4/r32/esp + 4689 # setup + 4690 (clear-stream _test-input-stream) + 4691 (clear-stream $_test-input-buffered-file->buffer) + 4692 (clear-stream _test-output-stream) + 4693 (clear-stream $_test-output-buffered-file->buffer) + 4694 # + 4695 (write _test-input-stream "fn foo {\n") + 4696 (write _test-input-stream " {\n") + 4697 (write _test-input-stream " var x: int\n") + 4698 (write _test-input-stream " loop-if->=\n") + 4699 (write _test-input-stream " increment x\n") + 4700 (write _test-input-stream " }\n") + 4701 (write _test-input-stream "}\n") + 4702 # convert + 4703 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4704 (flush _test-output-buffered-file) + 4705 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4711 # check output + 4712 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-conditional-loops-and-local-vars/0") + 4713 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-conditional-loops-and-local-vars/1") + 4714 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/2") + 4715 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-conditional-loops-and-local-vars/3") + 4716 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/4") + 4717 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/5") + 4718 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/6") + 4719 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-conditional-loops-and-local-vars/7") + 4720 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/8") + 4721 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-conditional-loops-and-local-vars/9") + 4722 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/10") + 4723 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/11") + 4724 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:loop/disp32" "F - test-convert-function-with-conditional-loops-and-local-vars/12") + 4725 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/13") + 4726 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-conditional-loops-and-local-vars/14") + 4727 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-conditional-loops-and-local-vars/15") + 4728 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/16") + 4729 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/17") + 4730 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-conditional-loops-and-local-vars/18") + 4731 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-conditional-loops-and-local-vars/19") + 4732 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-conditional-loops-and-local-vars/20") + 4733 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/21") + 4734 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-conditional-loops-and-local-vars/22") + 4735 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-conditional-loops-and-local-vars/23") + 4736 # . epilogue + 4737 89/<- %esp 5/r32/ebp + 4738 5d/pop-to-ebp + 4739 c3/return + 4740 + 4741 test-convert-function-with-unconditional-loops-and-local-vars: + 4742 # An unconditional 'loop' after a 'var' in a block is emitted _after_ the + 4743 # regular block cleanup. Any instructions after 'loop' are dead and + 4744 # therefore skipped. + 4745 # . prologue + 4746 55/push-ebp + 4747 89/<- %ebp 4/r32/esp + 4748 # setup + 4749 (clear-stream _test-input-stream) + 4750 (clear-stream $_test-input-buffered-file->buffer) + 4751 (clear-stream _test-output-stream) + 4752 (clear-stream $_test-output-buffered-file->buffer) + 4753 # + 4754 (write _test-input-stream "fn foo {\n") + 4755 (write _test-input-stream " {\n") + 4756 (write _test-input-stream " var x: int\n") + 4757 (write _test-input-stream " loop\n") + 4758 (write _test-input-stream " increment x\n") + 4759 (write _test-input-stream " }\n") + 4760 (write _test-input-stream "}\n") + 4761 # convert + 4762 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4763 (flush _test-output-buffered-file) + 4764 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4770 # check output + 4771 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-loops-and-local-vars/0") + 4772 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-loops-and-local-vars/1") + 4773 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/2") + 4774 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-loops-and-local-vars/3") + 4775 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/4") + 4776 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/5") + 4777 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-loops-and-local-vars/6") + 4778 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-loops-and-local-vars/7") + 4779 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/8") + 4780 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-loops-and-local-vars/9") + 4781 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-unconditional-loops-and-local-vars/10") + 4782 # not emitted: ff 0/subop/increment *(ebp+0xfffffffc) + 4783 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/11") + 4784 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/12") + 4785 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-loops-and-local-vars/13") + 4786 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-loops-and-local-vars/14") + 4787 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-loops-and-local-vars/15") + 4788 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/16") + 4789 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-loops-and-local-vars/17") + 4790 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-loops-and-local-vars/18") + 4791 # . epilogue + 4792 89/<- %esp 5/r32/ebp + 4793 5d/pop-to-ebp + 4794 c3/return + 4795 + 4796 test-convert-function-with-branches-and-loops-and-local-vars: + 4797 # . prologue + 4798 55/push-ebp + 4799 89/<- %ebp 4/r32/esp + 4800 # setup + 4801 (clear-stream _test-input-stream) + 4802 (clear-stream $_test-input-buffered-file->buffer) + 4803 (clear-stream _test-output-stream) + 4804 (clear-stream $_test-output-buffered-file->buffer) + 4805 # + 4806 (write _test-input-stream "fn foo {\n") + 4807 (write _test-input-stream " {\n") + 4808 (write _test-input-stream " var x: int\n") + 4809 (write _test-input-stream " break-if->=\n") + 4810 (write _test-input-stream " increment x\n") + 4811 (write _test-input-stream " loop\n") + 4812 (write _test-input-stream " }\n") + 4813 (write _test-input-stream "}\n") + 4814 # convert + 4815 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4816 (flush _test-output-buffered-file) + 4817 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4823 # check output + 4824 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-branches-and-loops-and-local-vars/0") + 4825 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-branches-and-loops-and-local-vars/1") + 4826 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/2") + 4827 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-branches-and-loops-and-local-vars/3") + 4828 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/4") + 4829 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/5") + 4830 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/6") + 4831 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-branches-and-loops-and-local-vars/7") + 4832 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/8") + 4833 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-branches-and-loops-and-local-vars/9") + 4834 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/10") + 4835 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/11") + 4836 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000002:break/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/12") + 4837 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/13") + 4838 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-branches-and-loops-and-local-vars/14") + 4839 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-branches-and-loops-and-local-vars/15") + 4840 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-branches-and-loops-and-local-vars/16") + 4841 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/17") + 4842 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/18") + 4843 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-branches-and-loops-and-local-vars/19") + 4844 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-branches-and-loops-and-local-vars/20") + 4845 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-branches-and-loops-and-local-vars/21") + 4846 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/22") + 4847 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-branches-and-loops-and-local-vars/23") + 4848 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-branches-and-loops-and-local-vars/24") + 4849 # . epilogue + 4850 89/<- %esp 5/r32/ebp + 4851 5d/pop-to-ebp + 4852 c3/return + 4853 + 4854 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars: + 4855 # . prologue + 4856 55/push-ebp + 4857 89/<- %ebp 4/r32/esp + 4858 # setup + 4859 (clear-stream _test-input-stream) + 4860 (clear-stream $_test-input-buffered-file->buffer) + 4861 (clear-stream _test-output-stream) + 4862 (clear-stream $_test-output-buffered-file->buffer) + 4863 # + 4864 (write _test-input-stream "fn foo {\n") + 4865 (write _test-input-stream " a: {\n") + 4866 (write _test-input-stream " var x: int\n") + 4867 (write _test-input-stream " {\n") + 4868 (write _test-input-stream " var y: int\n") + 4869 (write _test-input-stream " break-if->= a\n") + 4870 (write _test-input-stream " increment x\n") + 4871 (write _test-input-stream " loop\n") + 4872 (write _test-input-stream " }\n") + 4873 (write _test-input-stream " }\n") + 4874 (write _test-input-stream "}\n") + 4875 # convert + 4876 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4877 (flush _test-output-buffered-file) + 4878 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4884 # check output + 4885 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/0") + 4886 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/1") + 4887 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/2") + 4888 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/3") + 4889 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/4") + 4890 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/5") + 4891 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/6") + 4892 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/7") + 4893 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/8") + 4894 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/9") + 4895 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/10") + 4896 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/11") + 4897 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/12") + 4898 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/13") + 4899 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/14") + 4900 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/15") + 4901 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/16") + 4902 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/17") + 4903 (check-next-stream-line-equal _test-output-stream " ff 0/subop/increment *(ebp+0xfffffffc)" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/18") + 4904 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/19") + 4905 (check-next-stream-line-equal _test-output-stream " e9/jump loop/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/20") + 4906 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/21") + 4907 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/22") + 4908 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/23") + 4909 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/24") + 4910 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/25") + 4911 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/26") + 4912 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/27") + 4913 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/28") + 4914 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/29") + 4915 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/30") + 4916 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars/31") + 4917 # . epilogue + 4918 89/<- %esp 5/r32/ebp + 4919 5d/pop-to-ebp + 4920 c3/return + 4921 + 4922 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2: + 4923 # . prologue + 4924 55/push-ebp + 4925 89/<- %ebp 4/r32/esp + 4926 # setup + 4927 (clear-stream _test-input-stream) + 4928 (clear-stream $_test-input-buffered-file->buffer) + 4929 (clear-stream _test-output-stream) + 4930 (clear-stream $_test-output-buffered-file->buffer) + 4931 # non-local conditional branch from a block without a local variable, + 4932 # unwinding a local on the stack + 4933 (write _test-input-stream "fn foo {\n") + 4934 (write _test-input-stream " a: {\n") + 4935 (write _test-input-stream " var x: int\n") + 4936 (write _test-input-stream " {\n") + 4937 (write _test-input-stream " break-if->= a\n") + 4938 (write _test-input-stream " }\n") + 4939 (write _test-input-stream " }\n") + 4940 (write _test-input-stream "}\n") + 4941 # convert + 4942 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 4943 (flush _test-output-buffered-file) + 4944 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 4950 # check output + 4951 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/0") + 4952 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/1") + 4953 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/2") + 4954 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/3") + 4955 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/4") + 4956 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/5") + 4957 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/6") + 4958 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/7") + 4959 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/8") + 4960 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/9") + 4961 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/10") + 4962 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/11") + 4963 (check-next-stream-line-equal _test-output-stream " 0f 8c/jump-if-< break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/12") + 4964 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/13") + 4965 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/14") + 4966 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/15") + 4967 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/16") + 4968 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/17") + 4969 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/18") + 4970 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/19") + 4971 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/20") + 4972 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/21") + 4973 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/22") + 4974 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/23") + 4975 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/24") + 4976 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/25") + 4977 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-2/26") + 4978 # . epilogue + 4979 89/<- %esp 5/r32/ebp + 4980 5d/pop-to-ebp + 4981 c3/return + 4982 + 4983 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3: + 4984 # . prologue + 4985 55/push-ebp + 4986 89/<- %ebp 4/r32/esp + 4987 # setup + 4988 (clear-stream _test-input-stream) + 4989 (clear-stream $_test-input-buffered-file->buffer) + 4990 (clear-stream _test-output-stream) + 4991 (clear-stream $_test-output-buffered-file->buffer) + 4992 # non-local unconditional branch from a block without a local variable, + 4993 # unwinding a local on the stack + 4994 (write _test-input-stream "fn foo {\n") + 4995 (write _test-input-stream " a: {\n") + 4996 (write _test-input-stream " var x: int\n") + 4997 (write _test-input-stream " {\n") + 4998 (write _test-input-stream " break a\n") + 4999 (write _test-input-stream " }\n") + 5000 (write _test-input-stream " }\n") + 5001 (write _test-input-stream "}\n") + 5002 # convert + 5003 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5004 (flush _test-output-buffered-file) + 5005 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5011 # check output + 5012 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/0") + 5013 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/1") + 5014 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/2") + 5015 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/3") + 5016 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/4") + 5017 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/5") + 5018 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/6") + 5019 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/7") + 5020 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/8") + 5021 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/9") + 5022 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/10") + 5023 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/11") + 5024 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/12") + 5025 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/14") + 5026 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/15") + 5027 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/16") + 5028 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/17") + 5029 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/18") + 5030 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/19") + 5031 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/20") + 5032 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/21") + 5033 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/22") + 5034 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/23") + 5035 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-3/24") + 5036 # . epilogue + 5037 89/<- %esp 5/r32/ebp + 5038 5d/pop-to-ebp + 5039 c3/return + 5040 + 5041 test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4: + 5042 # . prologue + 5043 55/push-ebp + 5044 89/<- %ebp 4/r32/esp + 5045 # setup + 5046 (clear-stream _test-input-stream) + 5047 (clear-stream $_test-input-buffered-file->buffer) + 5048 (clear-stream _test-output-stream) + 5049 (clear-stream $_test-output-buffered-file->buffer) + 5050 # + 5051 (write _test-input-stream "fn foo {\n") + 5052 (write _test-input-stream " a: {\n") + 5053 (write _test-input-stream " var x/esi: int <- copy 0\n") + 5054 (write _test-input-stream " {\n") + 5055 (write _test-input-stream " break a\n") + 5056 (write _test-input-stream " }\n") + 5057 (write _test-input-stream " }\n") + 5058 (write _test-input-stream "}\n") + 5059 # convert + 5060 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5061 (flush _test-output-buffered-file) + 5062 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5068 # check output + 5069 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/0") + 5070 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/1") + 5071 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/2") + 5072 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/3") + 5073 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/4") + 5074 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/5") + 5075 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/6") + 5076 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/7") + 5077 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/8") + 5078 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/9") + 5079 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/10") + 5080 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/11") + 5081 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/12") + 5082 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/13") + 5083 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/14") + 5084 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/15") + 5085 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/16") + 5086 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/17") + 5087 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/18") + 5088 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/19") + 5089 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/20") + 5090 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/21") + 5091 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/22") + 5092 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/23") + 5093 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-branches-and-loops-and-local-vars-4/24") + 5094 # . epilogue + 5095 89/<- %esp 5/r32/ebp + 5096 5d/pop-to-ebp + 5097 c3/return + 5098 + 5099 test-convert-function-with-nonlocal-unconditional-break-and-local-vars: + 5100 # . prologue + 5101 55/push-ebp + 5102 89/<- %ebp 4/r32/esp + 5103 # setup + 5104 (clear-stream _test-input-stream) + 5105 (clear-stream $_test-input-buffered-file->buffer) + 5106 (clear-stream _test-output-stream) + 5107 (clear-stream $_test-output-buffered-file->buffer) + 5108 # + 5109 (write _test-input-stream "fn foo {\n") + 5110 (write _test-input-stream " a: {\n") + 5111 (write _test-input-stream " var x: int\n") + 5112 (write _test-input-stream " {\n") + 5113 (write _test-input-stream " var y: int\n") + 5114 (write _test-input-stream " break a\n") + 5115 (write _test-input-stream " increment x\n") + 5116 (write _test-input-stream " }\n") + 5117 (write _test-input-stream " }\n") + 5118 (write _test-input-stream "}\n") + 5119 # convert + 5120 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5121 (flush _test-output-buffered-file) + 5122 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5128 # check output + 5129 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/0") + 5130 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/1") + 5131 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/2") + 5132 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/3") + 5133 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/4") + 5134 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/5") + 5135 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/6") + 5136 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/7") + 5137 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/8") + 5138 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/9") + 5139 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/10") + 5140 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/11") + 5141 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/12") + 5142 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/13") + 5143 (check-next-stream-line-equal _test-output-stream " e9/jump a:break/disp32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/14") + 5144 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/15") + 5145 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/16") + 5146 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/17") + 5147 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/18") + 5148 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/19") + 5149 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/20") + 5150 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/21") + 5151 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/22") + 5152 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/23") + 5153 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/24") + 5154 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-break-and-local-vars/25") + 5155 # . epilogue + 5156 89/<- %esp 5/r32/ebp + 5157 5d/pop-to-ebp + 5158 c3/return + 5159 + 5160 test-convert-function-with-unconditional-break-and-local-vars: + 5161 # . prologue + 5162 55/push-ebp + 5163 89/<- %ebp 4/r32/esp + 5164 # setup + 5165 (clear-stream _test-input-stream) + 5166 (clear-stream $_test-input-buffered-file->buffer) + 5167 (clear-stream _test-output-stream) + 5168 (clear-stream $_test-output-buffered-file->buffer) + 5169 # + 5170 (write _test-input-stream "fn foo {\n") + 5171 (write _test-input-stream " {\n") + 5172 (write _test-input-stream " var x: int\n") + 5173 (write _test-input-stream " {\n") + 5174 (write _test-input-stream " var y: int\n") + 5175 (write _test-input-stream " break\n") + 5176 (write _test-input-stream " increment x\n") + 5177 (write _test-input-stream " }\n") + 5178 (write _test-input-stream " }\n") + 5179 (write _test-input-stream "}\n") + 5180 # convert + 5181 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5182 (flush _test-output-buffered-file) + 5183 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5189 # check output + 5190 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-unconditional-break-and-local-vars/0") + 5191 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-unconditional-break-and-local-vars/1") + 5192 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/2") + 5193 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-unconditional-break-and-local-vars/3") + 5194 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/4") + 5195 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/5") + 5196 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/6") + 5197 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/7") + 5198 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/8") + 5199 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-unconditional-break-and-local-vars/9") + 5200 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-unconditional-break-and-local-vars/10") + 5201 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/11") + 5202 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/12") + 5203 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/13") + 5204 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/14") + 5205 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-unconditional-break-and-local-vars/15") + 5206 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/16") + 5207 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/17") + 5208 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-unconditional-break-and-local-vars/18") + 5209 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-unconditional-break-and-local-vars/19") + 5210 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-unconditional-break-and-local-vars/20") + 5211 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/21") + 5212 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-unconditional-break-and-local-vars/22") + 5213 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-unconditional-break-and-local-vars/23") + 5214 # . epilogue + 5215 89/<- %esp 5/r32/ebp + 5216 5d/pop-to-ebp + 5217 c3/return + 5218 + 5219 test-convert-function-with-nonlocal-unconditional-loop-and-local-vars: + 5220 # . prologue + 5221 55/push-ebp + 5222 89/<- %ebp 4/r32/esp + 5223 # setup + 5224 (clear-stream _test-input-stream) + 5225 (clear-stream $_test-input-buffered-file->buffer) + 5226 (clear-stream _test-output-stream) + 5227 (clear-stream $_test-output-buffered-file->buffer) + 5228 # + 5229 (write _test-input-stream "fn foo {\n") + 5230 (write _test-input-stream " a: {\n") + 5231 (write _test-input-stream " var x: int\n") + 5232 (write _test-input-stream " {\n") + 5233 (write _test-input-stream " var y: int\n") + 5234 (write _test-input-stream " loop a\n") + 5235 (write _test-input-stream " increment x\n") + 5236 (write _test-input-stream " }\n") + 5237 (write _test-input-stream " }\n") + 5238 (write _test-input-stream "}\n") + 5239 # convert + 5240 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5241 (flush _test-output-buffered-file) + 5242 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5248 # check output + 5249 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/0") + 5250 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/1") + 5251 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/2") + 5252 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/3") + 5253 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/4") + 5254 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/5") + 5255 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/6") + 5256 (check-next-stream-line-equal _test-output-stream "a:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/7") + 5257 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/8") + 5258 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/9") + 5259 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/10") + 5260 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/11") + 5261 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/12") + 5262 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/13") + 5263 (check-next-stream-line-equal _test-output-stream " e9/jump a:loop/disp32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/14") + 5264 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/15") + 5265 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/16") + 5266 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/17") + 5267 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/18") + 5268 (check-next-stream-line-equal _test-output-stream "a:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/19") + 5269 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/20") + 5270 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/21") + 5271 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/22") + 5272 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/23") + 5273 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/24") + 5274 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-nonlocal-unconditional-loop-and-local-vars/25") + 5275 # . epilogue + 5276 89/<- %esp 5/r32/ebp + 5277 5d/pop-to-ebp + 5278 c3/return + 5279 + 5280 test-convert-function-with-local-array-var-in-mem: + 5281 # . prologue + 5282 55/push-ebp + 5283 89/<- %ebp 4/r32/esp + 5284 # setup + 5285 (clear-stream _test-input-stream) + 5286 (clear-stream $_test-input-buffered-file->buffer) + 5287 (clear-stream _test-output-stream) + 5288 (clear-stream $_test-output-buffered-file->buffer) + 5289 # + 5290 (write _test-input-stream "fn foo {\n") + 5291 (write _test-input-stream " var x: (array int 3)\n") + 5292 (write _test-input-stream "}\n") + 5293 # convert + 5294 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5295 (flush _test-output-buffered-file) + 5296 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5302 # check output + 5303 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-var-in-mem/0") + 5304 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-var-in-mem/1") + 5305 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-var-in-mem/2") + 5306 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-var-in-mem/3") + 5307 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-var-in-mem/4") + 5308 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-var-in-mem/5") + 5309 # define x + 5310 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-function-with-local-array-var-in-mem/7") + 5311 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-function-with-local-array-var-in-mem/8") + 5312 # reclaim x + 5313 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-function-with-local-array-var-in-mem/9") + 5314 # + 5315 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-var-in-mem/10") + 5316 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-var-in-mem/11") + 5317 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-var-in-mem/12") + 5318 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-var-in-mem/13") + 5319 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-var-in-mem/14") + 5320 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-var-in-mem/15") + 5321 # . epilogue + 5322 89/<- %esp 5/r32/ebp + 5323 5d/pop-to-ebp + 5324 c3/return + 5325 + 5326 test-array-size-in-hex: + 5327 # . prologue + 5328 55/push-ebp + 5329 89/<- %ebp 4/r32/esp + 5330 # setup + 5331 (clear-stream _test-input-stream) + 5332 (clear-stream $_test-input-buffered-file->buffer) + 5333 (clear-stream _test-output-stream) + 5334 (clear-stream $_test-output-buffered-file->buffer) + 5335 (clear-stream _test-error-stream) + 5336 (clear-stream $_test-error-buffered-file->buffer) + 5337 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 5338 68/push 0/imm32 + 5339 68/push 0/imm32 + 5340 89/<- %edx 4/r32/esp + 5341 (tailor-exit-descriptor %edx 0x10) + 5342 # + 5343 (write _test-input-stream "fn foo {\n") + 5344 (write _test-input-stream " var x: (array int 10)\n") + 5345 (write _test-input-stream "}\n") + 5346 # convert + 5347 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5348 # registers except esp clobbered at this point + 5349 # restore ed + 5350 89/<- %edx 4/r32/esp + 5351 (flush _test-output-buffered-file) + 5352 (flush _test-error-buffered-file) + 5353 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5359 # check output + 5360 (check-stream-equal _test-output-stream "" "F - test-array-size-in-hex: output should be empty") + 5361 (check-next-stream-line-equal _test-error-stream "literal integers are always hex in Mu; start '10' with a '0x' to be unambiguous, converting it to hexadecimal as necessary." "F - test-array-size-in-hex: error message") + 5362 # check that stop(1) was called + 5363 (check-ints-equal *(edx+4) 2 "F - test-array-size-in-hex: exit status") + 5364 # don't restore from ebp + 5365 81 0/subop/add %esp 8/imm32 + 5366 # . epilogue + 5367 5d/pop-to-ebp + 5368 c3/return + 5369 + 5370 test-convert-function-with-populate: + 5371 # . prologue + 5372 55/push-ebp + 5373 89/<- %ebp 4/r32/esp + 5374 # setup + 5375 (clear-stream _test-input-stream) + 5376 (clear-stream $_test-input-buffered-file->buffer) + 5377 (clear-stream _test-output-stream) + 5378 (clear-stream $_test-output-buffered-file->buffer) + 5379 # + 5380 (write _test-input-stream "fn foo {\n") + 5381 (write _test-input-stream " var x/ecx: (addr handle array int) <- copy 0\n") + 5382 (write _test-input-stream " populate x, 7\n") + 5383 (write _test-input-stream "}\n") + 5384 # convert + 5385 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5386 (flush _test-output-buffered-file) + 5387 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5393 # check output + 5394 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-populate/0") + 5395 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-populate/1") + 5396 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-populate/2") + 5397 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-populate/3") + 5398 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-populate/4") + 5399 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-populate/5") + 5400 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-populate/6") + 5401 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-function-with-populate/7") + 5402 (check-next-stream-line-equal _test-output-stream " (allocate-array2 Heap 0x00000004 7 %ecx)" "F - test-convert-function-with-populate/8") # 4 = size-of(int) + 5403 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-populate/9") + 5404 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-populate/10") + 5405 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-populate/11") + 5406 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-populate/12") + 5407 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-populate/13") + 5408 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-populate/14") + 5409 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-populate/15") + 5410 # . epilogue + 5411 89/<- %esp 5/r32/ebp + 5412 5d/pop-to-ebp + 5413 c3/return + 5414 + 5415 # special-case for size(byte) when allocating array + 5416 test-convert-function-with-local-array-of-bytes-in-mem: + 5417 # . prologue + 5418 55/push-ebp + 5419 89/<- %ebp 4/r32/esp + 5420 # setup + 5421 (clear-stream _test-input-stream) + 5422 (clear-stream $_test-input-buffered-file->buffer) + 5423 (clear-stream _test-output-stream) + 5424 (clear-stream $_test-output-buffered-file->buffer) + 5425 # + 5426 (write _test-input-stream "fn foo {\n") + 5427 (write _test-input-stream " var x: (array byte 3)\n") + 5428 (write _test-input-stream "}\n") + 5429 # convert + 5430 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5431 (flush _test-output-buffered-file) + 5432 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5438 # check output + 5439 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-array-of-bytes-in-mem/0") + 5440 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-array-of-bytes-in-mem/1") + 5441 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/2") + 5442 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-array-of-bytes-in-mem/3") + 5443 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-array-of-bytes-in-mem/4") + 5444 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-array-of-bytes-in-mem/5") + 5445 # define x + 5446 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-function-with-local-array-of-bytes-in-mem/7") + 5447 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/8") + 5448 # reclaim x + 5449 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-function-with-local-array-of-bytes-in-mem/9") + 5450 # + 5451 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-array-of-bytes-in-mem/10") + 5452 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-array-of-bytes-in-mem/11") + 5453 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-array-of-bytes-in-mem/12") + 5454 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/13") + 5455 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-array-of-bytes-in-mem/14") + 5456 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-array-of-bytes-in-mem/15") + 5457 # . epilogue + 5458 89/<- %esp 5/r32/ebp + 5459 5d/pop-to-ebp + 5460 c3/return + 5461 + 5462 test-convert-address: + 5463 # . prologue + 5464 55/push-ebp + 5465 89/<- %ebp 4/r32/esp + 5466 # setup + 5467 (clear-stream _test-input-stream) + 5468 (clear-stream $_test-input-buffered-file->buffer) + 5469 (clear-stream _test-output-stream) + 5470 (clear-stream $_test-output-buffered-file->buffer) + 5471 # + 5472 (write _test-input-stream "fn foo {\n") + 5473 (write _test-input-stream " var a: int\n") + 5474 (write _test-input-stream " var b/eax: (addr int) <- address a\n") + 5475 (write _test-input-stream "}\n") + 5476 # convert + 5477 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5478 (flush _test-output-buffered-file) + 5479 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5485 # check output + 5486 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-address/0") + 5487 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-address/1") + 5488 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-address/2") + 5489 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-address/3") + 5490 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-address/4") + 5491 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-address/5") + 5492 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-address/6") + 5493 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-address/7") + 5494 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000000/r32" "F - test-convert-address/8") + 5495 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-address/9") + 5496 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-address/10") + 5497 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-address/11") + 5498 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-address/12") + 5499 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-address/13") + 5500 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-address/14") + 5501 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-address/15") + 5502 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-address/16") + 5503 # . epilogue + 5504 89/<- %esp 5/r32/ebp + 5505 5d/pop-to-ebp + 5506 c3/return + 5507 + 5508 test-convert-floating-point-convert: + 5509 # . prologue + 5510 55/push-ebp + 5511 89/<- %ebp 4/r32/esp + 5512 # setup + 5513 (clear-stream _test-input-stream) + 5514 (clear-stream $_test-input-buffered-file->buffer) + 5515 (clear-stream _test-output-stream) + 5516 (clear-stream $_test-output-buffered-file->buffer) + 5517 # + 5518 (write _test-input-stream "fn foo {\n") + 5519 (write _test-input-stream " var a/eax: int <- copy 0\n") + 5520 (write _test-input-stream " var b/xmm1: float <- convert a\n") + 5521 (write _test-input-stream "}\n") + 5522 # convert + 5523 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5524 (flush _test-output-buffered-file) + 5525 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5531 # check output + 5532 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-floating-point-convert/0") + 5533 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-convert/1") + 5534 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-convert/2") + 5535 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-convert/3") + 5536 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-convert/4") + 5537 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-floating-point-convert/5") + 5538 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-floating-point-convert/6") + 5539 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-floating-point-convert/7") + 5540 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-convert/8") + 5541 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-convert/9") + 5542 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000001/x32" "F - test-convert-floating-point-convert/10") + 5543 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-convert/11") + 5544 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-floating-point-convert/12") + 5545 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-floating-point-convert/13") + 5546 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-convert/14") + 5547 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-floating-point-convert/15") + 5548 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-convert/16") + 5549 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-convert/17") + 5550 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-convert/18") + 5551 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-convert/19") + 5552 # . epilogue + 5553 89/<- %esp 5/r32/ebp + 5554 5d/pop-to-ebp + 5555 c3/return + 5556 + 5557 test-convert-floating-point-convert-2: + 5558 # . prologue + 5559 55/push-ebp + 5560 89/<- %ebp 4/r32/esp + 5561 # setup + 5562 (clear-stream _test-input-stream) + 5563 (clear-stream $_test-input-buffered-file->buffer) + 5564 (clear-stream _test-output-stream) + 5565 (clear-stream $_test-output-buffered-file->buffer) + 5566 # + 5567 (write _test-input-stream "fn foo {\n") + 5568 (write _test-input-stream " var a/eax: int <- copy 0\n") + 5569 (write _test-input-stream " var b/xmm1: float <- convert a\n") + 5570 (write _test-input-stream " a <- convert b\n") + 5571 (write _test-input-stream "}\n") + 5572 # convert + 5573 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5574 (flush _test-output-buffered-file) + 5575 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5581 # check output + 5582 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-floating-point-convert-2/0") + 5583 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-convert-2/1") + 5584 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-convert-2/2") + 5585 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-convert-2/3") + 5586 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-convert-2/4") + 5587 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-floating-point-convert-2/5") + 5588 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-floating-point-convert-2/6") + 5589 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-floating-point-convert-2/7") + 5590 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-convert-2/8") + 5591 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-convert-2/9") + 5592 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000001/x32" "F - test-convert-floating-point-convert-2/10") + 5593 (check-next-stream-line-equal _test-output-stream " f3 0f 2d/convert-to-int %xmm1 0x00000000/r32" "F - test-convert-floating-point-convert-2/11") + 5594 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-convert-2/12") + 5595 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-floating-point-convert-2/13") + 5596 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-floating-point-convert-2/14") + 5597 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-convert-2/15") + 5598 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-floating-point-convert-2/16") + 5599 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-convert-2/17") + 5600 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-convert-2/18") + 5601 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-convert-2/19") + 5602 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-convert-2/20") + 5603 # . epilogue + 5604 89/<- %esp 5/r32/ebp + 5605 5d/pop-to-ebp + 5606 c3/return + 5607 + 5608 test-convert-floating-point-operation: + 5609 # . prologue + 5610 55/push-ebp + 5611 89/<- %ebp 4/r32/esp + 5612 # setup + 5613 (clear-stream _test-input-stream) + 5614 (clear-stream $_test-input-buffered-file->buffer) + 5615 (clear-stream _test-output-stream) + 5616 (clear-stream $_test-output-buffered-file->buffer) + 5617 # + 5618 (write _test-input-stream "fn f {\n") + 5619 (write _test-input-stream " var m: float\n") + 5620 (write _test-input-stream " var x/xmm1: float <- copy m\n") + 5621 (write _test-input-stream " var y/xmm5: float <- copy m\n") + 5622 (write _test-input-stream " x <- copy y\n") + 5623 (write _test-input-stream " copy-to m, y\n") + 5624 (write _test-input-stream " x <- add y\n") + 5625 (write _test-input-stream " x <- add m\n") + 5626 (write _test-input-stream " x <- subtract y\n") + 5627 (write _test-input-stream " x <- subtract m\n") + 5628 (write _test-input-stream " x <- multiply y\n") + 5629 (write _test-input-stream " x <- multiply m\n") + 5630 (write _test-input-stream " x <- divide y\n") + 5631 (write _test-input-stream " x <- divide m\n") + 5632 (write _test-input-stream " x <- reciprocal y\n") + 5633 (write _test-input-stream " x <- reciprocal m\n") + 5634 (write _test-input-stream " x <- square-root y\n") + 5635 (write _test-input-stream " x <- square-root m\n") + 5636 (write _test-input-stream " x <- inverse-square-root y\n") + 5637 (write _test-input-stream " x <- inverse-square-root m\n") + 5638 (write _test-input-stream " x <- max y\n") + 5639 (write _test-input-stream " x <- max m\n") + 5640 (write _test-input-stream " x <- min y\n") + 5641 (write _test-input-stream " x <- min m\n") + 5642 (write _test-input-stream " compare x, y\n") + 5643 (write _test-input-stream " compare x, m\n") + 5644 (write _test-input-stream "}\n") + 5645 # convert + 5646 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5647 (flush _test-output-buffered-file) + 5648 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5654 # check output + 5655 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-floating-point-operation/0") + 5656 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-operation/1") + 5657 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-operation/2") + 5658 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-operation/3") + 5659 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-operation/4") + 5660 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-floating-point-operation/5") + 5661 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-floating-point-operation/6") + 5662 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-operation/7") + 5663 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-operation/8") + 5664 (check-next-stream-line-equal _test-output-stream " f3 0f 10/copy *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/9") + 5665 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-operation/10") + 5666 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 5/x32" "F - test-convert-floating-point-operation/11") + 5667 (check-next-stream-line-equal _test-output-stream " f3 0f 10/copy *(ebp+0xfffffffc) 0x00000005/x32" "F - test-convert-floating-point-operation/12") + 5668 (check-next-stream-line-equal _test-output-stream " f3 0f 11/copy %xmm1 0x00000005/x32" "F - test-convert-floating-point-operation/13") + 5669 (check-next-stream-line-equal _test-output-stream " f3 0f 11/copy *(ebp+0xfffffffc) 0x00000005/x32" "F - test-convert-floating-point-operation/14") + 5670 (check-next-stream-line-equal _test-output-stream " f3 0f 58/add %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/15") + 5671 (check-next-stream-line-equal _test-output-stream " f3 0f 58/add *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/16") + 5672 (check-next-stream-line-equal _test-output-stream " f3 0f 5c/subtract %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/17") + 5673 (check-next-stream-line-equal _test-output-stream " f3 0f 5c/subtract *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/18") + 5674 (check-next-stream-line-equal _test-output-stream " f3 0f 59/multiply %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/19") + 5675 (check-next-stream-line-equal _test-output-stream " f3 0f 59/multiply *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/20") + 5676 (check-next-stream-line-equal _test-output-stream " f3 0f 5e/divide %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/21") + 5677 (check-next-stream-line-equal _test-output-stream " f3 0f 5e/divide *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/22") + 5678 (check-next-stream-line-equal _test-output-stream " f3 0f 53/reciprocal %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/23") + 5679 (check-next-stream-line-equal _test-output-stream " f3 0f 53/reciprocal *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/24") + 5680 (check-next-stream-line-equal _test-output-stream " f3 0f 51/square-root %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/25") + 5681 (check-next-stream-line-equal _test-output-stream " f3 0f 51/square-root *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/26") + 5682 (check-next-stream-line-equal _test-output-stream " f3 0f 52/inverse-square-root %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/27") + 5683 (check-next-stream-line-equal _test-output-stream " f3 0f 52/inverse-square-root *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/28") + 5684 (check-next-stream-line-equal _test-output-stream " f3 0f 5f/max %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/29") + 5685 (check-next-stream-line-equal _test-output-stream " f3 0f 5f/max *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/30") + 5686 (check-next-stream-line-equal _test-output-stream " f3 0f 5d/min %xmm5 0x00000001/x32" "F - test-convert-floating-point-operation/31") + 5687 (check-next-stream-line-equal _test-output-stream " f3 0f 5d/min *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/32") + 5688 (check-next-stream-line-equal _test-output-stream " 0f 2f/compare %xmm1 0x00000005/x32" "F - test-convert-floating-point-operation/33") + 5689 (check-next-stream-line-equal _test-output-stream " 0f 2f/compare *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-operation/34") + 5690 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 5/x32" "F - test-convert-floating-point-operation/35") + 5691 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-operation/36") + 5692 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-operation/37") + 5693 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-operation/38") + 5694 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-floating-point-operation/39") + 5695 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-operation/40") + 5696 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-floating-point-operation/41") + 5697 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-operation/42") + 5698 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-operation/43") + 5699 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-operation/44") + 5700 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-operation/45") + 5701 # . epilogue + 5702 89/<- %esp 5/r32/ebp + 5703 5d/pop-to-ebp + 5704 c3/return + 5705 + 5706 test-convert-floating-point-dereferenced: + 5707 # . prologue + 5708 55/push-ebp + 5709 89/<- %ebp 4/r32/esp + 5710 # setup + 5711 (clear-stream _test-input-stream) + 5712 (clear-stream $_test-input-buffered-file->buffer) + 5713 (clear-stream _test-output-stream) + 5714 (clear-stream $_test-output-buffered-file->buffer) + 5715 # + 5716 (write _test-input-stream "fn f {\n") + 5717 (write _test-input-stream " var m: float\n") + 5718 (write _test-input-stream " var x/xmm1: float <- copy m\n") + 5719 (write _test-input-stream " var y/eax: (addr float) <- copy 0\n") + 5720 (write _test-input-stream " x <- multiply *y\n") + 5721 (write _test-input-stream "}\n") + 5722 # convert + 5723 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5724 (flush _test-output-buffered-file) + 5725 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5731 # check output + 5732 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-floating-point-dereferenced/0") + 5733 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-floating-point-dereferenced/1") + 5734 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-floating-point-dereferenced/2") + 5735 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-floating-point-dereferenced/3") + 5736 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-floating-point-dereferenced/4") + 5737 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-floating-point-dereferenced/5") + 5738 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-floating-point-dereferenced/6") + 5739 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-floating-point-dereferenced/7") + 5740 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-floating-point-dereferenced/8") + 5741 (check-next-stream-line-equal _test-output-stream " f3 0f 10/copy *(ebp+0xfffffffc) 0x00000001/x32" "F - test-convert-floating-point-dereferenced/9") + 5742 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-floating-point-dereferenced/10") + 5743 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-floating-point-dereferenced/11") + 5744 (check-next-stream-line-equal _test-output-stream " f3 0f 59/multiply *eax 0x00000001/x32" "F - test-convert-floating-point-dereferenced/12") + 5745 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-floating-point-dereferenced/13") + 5746 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 1/x32" "F - test-convert-floating-point-dereferenced/14") + 5747 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-dereferenced/15") + 5748 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-floating-point-dereferenced/16") + 5749 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-floating-point-dereferenced/17") + 5750 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-floating-point-dereferenced/18") + 5751 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-floating-point-dereferenced/19") + 5752 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-floating-point-dereferenced/20") + 5753 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-floating-point-dereferenced/21") + 5754 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-floating-point-dereferenced/22") + 5755 # . epilogue + 5756 89/<- %esp 5/r32/ebp + 5757 5d/pop-to-ebp + 5758 c3/return + 5759 + 5760 test-convert-length-of-array: + 5761 # . prologue + 5762 55/push-ebp + 5763 89/<- %ebp 4/r32/esp + 5764 # setup + 5765 (clear-stream _test-input-stream) + 5766 (clear-stream $_test-input-buffered-file->buffer) + 5767 (clear-stream _test-output-stream) + 5768 (clear-stream $_test-output-buffered-file->buffer) + 5769 # + 5770 (write _test-input-stream "fn foo a: (addr array int) {\n") + 5771 (write _test-input-stream " var b/eax: (addr array int) <- copy a\n") + 5772 (write _test-input-stream " var c/eax: int <- length b\n") + 5773 (write _test-input-stream "}\n") + 5774 # convert + 5775 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5776 (flush _test-output-buffered-file) + 5777 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5783 # check output + 5784 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array/0") + 5785 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array/1") + 5786 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array/2") + 5787 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array/3") + 5788 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array/4") + 5789 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array/5") + 5790 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array/6") + 5791 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array/7") + 5792 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array/8") + 5793 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array/9") + 5794 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array/10") + 5795 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array/11") + 5796 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array/12") + 5797 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array/13") + 5798 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array/14") + 5799 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array/15") + 5800 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array/16") + 5801 # . epilogue + 5802 89/<- %esp 5/r32/ebp + 5803 5d/pop-to-ebp + 5804 c3/return + 5805 + 5806 # special-case for size(byte) when computing array length + 5807 test-convert-length-of-array-of-bytes: + 5808 # . prologue + 5809 55/push-ebp + 5810 89/<- %ebp 4/r32/esp + 5811 # setup + 5812 (clear-stream _test-input-stream) + 5813 (clear-stream $_test-input-buffered-file->buffer) + 5814 (clear-stream _test-output-stream) + 5815 (clear-stream $_test-output-buffered-file->buffer) + 5816 # + 5817 (write _test-input-stream "fn foo a: (addr array byte) {\n") + 5818 (write _test-input-stream " var b/eax: (addr array byte) <- copy a\n") + 5819 (write _test-input-stream " var c/eax: int <- length b\n") + 5820 (write _test-input-stream "}\n") + 5821 # convert + 5822 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5823 (flush _test-output-buffered-file) + 5824 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5830 # check output + 5831 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-bytes/0") + 5832 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-bytes/1") + 5833 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-bytes/2") + 5834 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-bytes/3") + 5835 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-bytes/4") + 5836 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-bytes/5") + 5837 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-bytes/6") + 5838 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/7") + 5839 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-bytes/8") + 5840 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-bytes/9") + 5841 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-bytes/10") + 5842 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-bytes/11") + 5843 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-bytes/12") + 5844 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-bytes/13") + 5845 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-bytes/14") + 5846 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-bytes/15") + 5847 # . epilogue + 5848 89/<- %esp 5/r32/ebp + 5849 5d/pop-to-ebp + 5850 c3/return + 5851 + 5852 test-convert-length-of-array-on-stack: + 5853 # . prologue + 5854 55/push-ebp + 5855 89/<- %ebp 4/r32/esp + 5856 # setup + 5857 (clear-stream _test-input-stream) + 5858 (clear-stream $_test-input-buffered-file->buffer) + 5859 (clear-stream _test-output-stream) + 5860 (clear-stream $_test-output-buffered-file->buffer) + 5861 # + 5862 (write _test-input-stream "fn foo {\n") + 5863 (write _test-input-stream " var a: (array int 3)\n") + 5864 (write _test-input-stream " var b/eax: int <- length a\n") + 5865 (write _test-input-stream "}\n") + 5866 # convert + 5867 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5868 (flush _test-output-buffered-file) + 5869 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5875 # check output + 5876 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-on-stack/0") + 5877 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-on-stack/1") + 5878 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-on-stack/2") + 5879 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-on-stack/3") + 5880 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-on-stack/4") + 5881 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-on-stack/5") + 5882 # define x + 5883 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-length-of-array-on-stack/6") + 5884 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-length-of-array-on-stack/7") + 5885 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-on-stack/8") + 5886 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffff0) 0x00000000/r32" "F - test-convert-length-of-array-on-stack/9") + 5887 (check-next-stream-line-equal _test-output-stream " c1/shift 5/subop/>> %eax 0x00000002/imm8" "F - test-convert-length-of-array-on-stack/10") + 5888 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-on-stack/11") + 5889 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-length-of-array-on-stack/12") + 5890 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-on-stack/13") + 5891 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-on-stack/14") + 5892 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-on-stack/15") + 5893 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-on-stack/16") + 5894 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-on-stack/17") + 5895 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-on-stack/18") + 5896 # . epilogue + 5897 89/<- %esp 5/r32/ebp + 5898 5d/pop-to-ebp + 5899 c3/return + 5900 + 5901 test-reg-var-def-with-read-of-same-register: + 5902 # . prologue + 5903 55/push-ebp + 5904 89/<- %ebp 4/r32/esp + 5905 # setup + 5906 (clear-stream _test-input-stream) + 5907 (clear-stream $_test-input-buffered-file->buffer) + 5908 (clear-stream _test-output-stream) + 5909 (clear-stream $_test-output-buffered-file->buffer) + 5910 (clear-stream _test-error-stream) + 5911 (clear-stream $_test-error-buffered-file->buffer) + 5912 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) # bytes of args in call to convert-mu + 5913 68/push 0/imm32 + 5914 68/push 0/imm32 + 5915 89/<- %edx 4/r32/esp + 5916 (tailor-exit-descriptor %edx 0x10) + 5917 # + 5918 (write _test-input-stream "fn foo {\n") + 5919 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 5920 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 5921 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") + 5922 (write _test-input-stream "}\n") + 5923 # convert + 5924 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 5925 # registers except esp could be clobbered at this point (though they shouldn't be) + 5926 # restore ed + 5927 89/<- %edx 4/r32/esp + 5928 (flush _test-output-buffered-file) + 5929 (flush _test-error-buffered-file) + 5930 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5936 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5942 (check-stream-equal _test-error-stream "" "F - test-reg-var-def-with-read-of-same-register: error stream should be empty") + 5943 # check output + 5944 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-reg-var-def-with-read-of-same-register/0") + 5945 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-reg-var-def-with-read-of-same-register/1") + 5946 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-reg-var-def-with-read-of-same-register/2") + 5947 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-reg-var-def-with-read-of-same-register/3") + 5948 (check-next-stream-line-equal _test-output-stream " {" "F - test-reg-var-def-with-read-of-same-register/4") + 5949 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-reg-var-def-with-read-of-same-register/5") + 5950 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-reg-var-def-with-read-of-same-register/6") + 5951 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-reg-var-def-with-read-of-same-register/7") + 5952 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-reg-var-def-with-read-of-same-register/8") + 5953 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-reg-var-def-with-read-of-same-register/9") + 5954 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000002 + 4) 0x00000000/r32" "F - test-reg-var-def-with-read-of-same-register/11") + 5955 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-reg-var-def-with-read-of-same-register/13") + 5956 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-reg-var-def-with-read-of-same-register/14") + 5957 (check-next-stream-line-equal _test-output-stream " }" "F - test-reg-var-def-with-read-of-same-register/15") + 5958 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-reg-var-def-with-read-of-same-register/16") + 5959 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-reg-var-def-with-read-of-same-register/17") + 5960 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-reg-var-def-with-read-of-same-register/18") + 5961 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-reg-var-def-with-read-of-same-register/19") + 5962 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-reg-var-def-with-read-of-same-register/20") + 5963 # don't restore from ebp + 5964 81 0/subop/add %esp 8/imm32 + 5965 # . epilogue + 5966 5d/pop-to-ebp + 5967 c3/return + 5968 + 5969 test-convert-index-into-array: + 5970 # . prologue + 5971 55/push-ebp + 5972 89/<- %ebp 4/r32/esp + 5973 # setup + 5974 (clear-stream _test-input-stream) + 5975 (clear-stream $_test-input-buffered-file->buffer) + 5976 (clear-stream _test-output-stream) + 5977 (clear-stream $_test-output-buffered-file->buffer) + 5978 # + 5979 (write _test-input-stream "fn foo {\n") + 5980 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 5981 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 5982 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") + 5983 (write _test-input-stream "}\n") + 5984 # convert + 5985 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 5986 (flush _test-output-buffered-file) + 5987 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 5993 # check output + 5994 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array/0") + 5995 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array/1") + 5996 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array/2") + 5997 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array/3") + 5998 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array/4") + 5999 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array/5") + 6000 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array/6") + 6001 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array/7") + 6002 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array/8") + 6003 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array/9") + 6004 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000002 + 4) 0x00000000/r32" "F - test-convert-index-into-array/10") + 6005 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array/11") + 6006 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array/12") + 6007 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array/13") + 6008 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array/14") + 6009 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array/15") + 6010 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array/16") + 6011 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array/17") + 6012 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array/18") + 6013 # . epilogue + 6014 89/<- %esp 5/r32/ebp + 6015 5d/pop-to-ebp + 6016 c3/return + 6017 + 6018 test-convert-index-into-array-of-bytes: + 6019 # . prologue + 6020 55/push-ebp + 6021 89/<- %ebp 4/r32/esp + 6022 # setup + 6023 (clear-stream _test-input-stream) + 6024 (clear-stream $_test-input-buffered-file->buffer) + 6025 (clear-stream _test-output-stream) + 6026 (clear-stream $_test-output-buffered-file->buffer) 6027 # - 6028 (write _test-input-stream "type t {\n") - 6029 (write _test-input-stream " a: (array int 3)\n") - 6030 (write _test-input-stream "}\n") - 6031 # convert - 6032 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6033 # registers except esp clobbered at this point - 6034 # restore ed - 6035 89/<- %edx 4/r32/esp - 6036 (flush _test-output-buffered-file) - 6037 (flush _test-error-buffered-file) - 6038 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6044 # check output - 6045 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-array: output should be empty") - 6046 (check-next-stream-line-equal _test-error-stream "type t: 'array' elements not allowed for now" "F - test-type-definition-with-array: error message") - 6047 # check that stop(1) was called - 6048 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-array: exit status") - 6049 # don't restore from ebp - 6050 81 0/subop/add %esp 8/imm32 - 6051 # . epilogue - 6052 5d/pop-to-ebp - 6053 c3/return - 6054 - 6055 test-type-definition-with-addr: - 6056 # . prologue - 6057 55/push-ebp - 6058 89/<- %ebp 4/r32/esp - 6059 # setup - 6060 (clear-stream _test-input-stream) - 6061 (clear-stream $_test-input-buffered-file->buffer) - 6062 (clear-stream _test-output-stream) - 6063 (clear-stream $_test-output-buffered-file->buffer) - 6064 (clear-stream _test-error-stream) - 6065 (clear-stream $_test-error-buffered-file->buffer) - 6066 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6067 68/push 0/imm32 - 6068 68/push 0/imm32 - 6069 89/<- %edx 4/r32/esp - 6070 (tailor-exit-descriptor %edx 0x10) - 6071 # - 6072 (write _test-input-stream "type t {\n") - 6073 (write _test-input-stream " a: (addr int)\n") - 6074 (write _test-input-stream "}\n") - 6075 # convert - 6076 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6077 # registers except esp clobbered at this point - 6078 # restore ed - 6079 89/<- %edx 4/r32/esp - 6080 (flush _test-output-buffered-file) - 6081 (flush _test-error-buffered-file) - 6082 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6088 # check output - 6089 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-addr: output should be empty") - 6090 (check-next-stream-line-equal _test-error-stream "type t: 'addr' elements not allowed" "F - test-type-definition-with-addr: error message") - 6091 # check that stop(1) was called - 6092 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-addr: exit status") - 6093 # don't restore from ebp - 6094 81 0/subop/add %esp 8/imm32 - 6095 # . epilogue - 6096 5d/pop-to-ebp - 6097 c3/return - 6098 - 6099 test-convert-function-with-local-var-with-user-defined-type: - 6100 # . prologue - 6101 55/push-ebp - 6102 89/<- %ebp 4/r32/esp - 6103 # setup - 6104 (clear-stream _test-input-stream) - 6105 (clear-stream $_test-input-buffered-file->buffer) - 6106 (clear-stream _test-output-stream) - 6107 (clear-stream $_test-output-buffered-file->buffer) - 6108 # - 6109 (write _test-input-stream "fn foo {\n") - 6110 (write _test-input-stream " var a: t\n") - 6111 (write _test-input-stream "}\n") - 6112 (write _test-input-stream "type t {\n") - 6113 (write _test-input-stream " x: int\n") - 6114 (write _test-input-stream " y: int\n") - 6115 (write _test-input-stream "}\n") - 6116 # convert - 6117 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6118 (flush _test-output-buffered-file) - 6119 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6125 # check output - 6126 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type/0") - 6127 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type/1") - 6128 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/2") - 6129 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-user-defined-type/3") - 6130 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-user-defined-type/4") - 6131 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-user-defined-type/5") - 6132 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/6") - 6133 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/7") - 6134 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/8") - 6135 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-user-defined-type/9") - 6136 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-user-defined-type/10") - 6137 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-user-defined-type/11") - 6138 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-user-defined-type/12") - 6139 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/13") - 6140 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-user-defined-type/14") - 6141 # . epilogue - 6142 89/<- %esp 5/r32/ebp - 6143 5d/pop-to-ebp - 6144 c3/return - 6145 - 6146 test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type: - 6147 # . prologue - 6148 55/push-ebp - 6149 89/<- %ebp 4/r32/esp - 6150 # setup - 6151 (clear-stream _test-input-stream) - 6152 (clear-stream $_test-input-buffered-file->buffer) - 6153 (clear-stream _test-output-stream) - 6154 (clear-stream $_test-output-buffered-file->buffer) - 6155 # - 6156 (write _test-input-stream "fn foo {\n") - 6157 (write _test-input-stream " var a: t\n") - 6158 (write _test-input-stream "}\n") - 6159 (write _test-input-stream "type t {\n") - 6160 (write _test-input-stream " x: s\n") - 6161 (write _test-input-stream "}\n") - 6162 (write _test-input-stream "type s {\n") - 6163 (write _test-input-stream " z: int\n") - 6164 (write _test-input-stream "}\n") - 6165 # convert - 6166 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6167 (flush _test-output-buffered-file) - 6168 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6174 # check output - 6175 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/0") - 6176 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/1") - 6177 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/2") - 6178 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/3") - 6179 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/4") - 6180 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/5") - 6181 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/7") - 6182 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/8") - 6183 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/9") - 6184 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/10") - 6185 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/11") - 6186 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/12") - 6187 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/13") - 6188 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/14") - 6189 # . epilogue - 6190 89/<- %esp 5/r32/ebp - 6191 5d/pop-to-ebp - 6192 c3/return - 6193 - 6194 test-convert-function-call-with-arg-of-user-defined-type: - 6195 # . prologue - 6196 55/push-ebp - 6197 89/<- %ebp 4/r32/esp - 6198 # setup - 6199 (clear-stream _test-input-stream) - 6200 (clear-stream $_test-input-buffered-file->buffer) - 6201 (clear-stream _test-output-stream) - 6202 (clear-stream $_test-output-buffered-file->buffer) - 6203 # - 6204 (write _test-input-stream "fn f {\n") - 6205 (write _test-input-stream " var a: t\n") - 6206 (write _test-input-stream " foo a\n") - 6207 (write _test-input-stream "}\n") - 6208 (write _test-input-stream "fn foo x: t {\n") - 6209 (write _test-input-stream "}\n") - 6210 (write _test-input-stream "type t {\n") - 6211 (write _test-input-stream " x: int\n") - 6212 (write _test-input-stream " y: int\n") - 6213 (write _test-input-stream "}\n") - 6214 # convert - 6215 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6216 (flush _test-output-buffered-file) - 6217 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6223 # check output - 6224 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") - 6225 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") - 6226 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2") - 6227 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3") - 6228 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4") - 6229 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5") - 6230 # var a: t - 6231 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/6") - 6232 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7") - 6233 # foo a - 6234 (check-next-stream-line-equal _test-output-stream " (foo *(ebp+0xfffffff8) *(ebp+0xfffffffc))" "F - test-convert-function-call-with-arg-of-user-defined-type/8") - 6235 # - 6236 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/9") - 6237 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10") - 6238 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11") - 6239 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12") - 6240 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13") - 6241 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14") - 6242 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15") - 6243 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16") - 6244 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17") - 6245 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18") - 6246 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19") - 6247 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20") - 6248 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21") - 6249 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22") - 6250 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23") - 6251 # . epilogue - 6252 89/<- %esp 5/r32/ebp - 6253 5d/pop-to-ebp - 6254 c3/return - 6255 - 6256 test-convert-function-call-with-arg-of-user-defined-type-register-indirect: - 6257 # . prologue - 6258 55/push-ebp - 6259 89/<- %ebp 4/r32/esp - 6260 # setup - 6261 (clear-stream _test-input-stream) - 6262 (clear-stream $_test-input-buffered-file->buffer) - 6263 (clear-stream _test-output-stream) - 6264 (clear-stream $_test-output-buffered-file->buffer) - 6265 # - 6266 (write _test-input-stream "fn f {\n") - 6267 (write _test-input-stream " var a/eax: (addr t) <- copy 0\n") - 6268 (write _test-input-stream " foo *a\n") - 6269 (write _test-input-stream "}\n") - 6270 (write _test-input-stream "fn foo x: t {\n") - 6271 (write _test-input-stream "}\n") - 6272 (write _test-input-stream "type t {\n") - 6273 (write _test-input-stream " x: int\n") - 6274 (write _test-input-stream " y: int\n") - 6275 (write _test-input-stream "}\n") - 6276 # convert - 6277 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6278 (flush _test-output-buffered-file) - 6279 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6285 # check output - 6286 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") - 6287 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") - 6288 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2") - 6289 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3") - 6290 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4") - 6291 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5") - 6292 # var a - 6293 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/6") - 6294 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7") - 6295 # foo a - 6296 (check-next-stream-line-equal _test-output-stream " (foo *(eax+0x00000000) *(eax+0x00000004))" "F - test-convert-function-call-with-arg-of-user-defined-type/8") - 6297 # - 6298 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/9") - 6299 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10") - 6300 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11") - 6301 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12") - 6302 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13") - 6303 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14") - 6304 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15") - 6305 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16") - 6306 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17") - 6307 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18") - 6308 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19") - 6309 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20") - 6310 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21") - 6311 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22") - 6312 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23") - 6313 # . epilogue - 6314 89/<- %esp 5/r32/ebp - 6315 5d/pop-to-ebp - 6316 c3/return - 6317 - 6318 # we don't have special support for call-by-reference; just explicitly create - 6319 # a new variable with the address of the arg - 6320 test-convert-function-call-with-arg-of-user-defined-type-by-reference: + 6028 (write _test-input-stream "fn foo {\n") + 6029 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") + 6030 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 6031 (write _test-input-stream " var x/eax: (addr byte) <- index arr, idx\n") + 6032 (write _test-input-stream "}\n") + 6033 # convert + 6034 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6035 (flush _test-output-buffered-file) + 6036 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6042 # check output + 6043 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes/0") + 6044 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes/1") + 6045 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes/2") + 6046 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes/3") + 6047 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes/4") + 6048 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes/5") + 6049 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes/6") + 6050 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes/7") + 6051 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes/8") + 6052 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes/9") + 6053 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000000 + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes/11") + 6054 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes/13") + 6055 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes/14") + 6056 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes/15") + 6057 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes/16") + 6058 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes/17") + 6059 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes/18") + 6060 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes/19") + 6061 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes/20") + 6062 # . epilogue + 6063 89/<- %esp 5/r32/ebp + 6064 5d/pop-to-ebp + 6065 c3/return + 6066 + 6067 test-convert-index-into-array-with-literal: + 6068 # . prologue + 6069 55/push-ebp + 6070 89/<- %ebp 4/r32/esp + 6071 # setup + 6072 (clear-stream _test-input-stream) + 6073 (clear-stream $_test-input-buffered-file->buffer) + 6074 (clear-stream _test-output-stream) + 6075 (clear-stream $_test-output-buffered-file->buffer) + 6076 # + 6077 (write _test-input-stream "fn foo {\n") + 6078 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 6079 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n") + 6080 (write _test-input-stream "}\n") + 6081 # convert + 6082 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6083 (flush _test-output-buffered-file) + 6084 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6090 # check output + 6091 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-with-literal/0") + 6092 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-with-literal/1") + 6093 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-with-literal/2") + 6094 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-with-literal/3") + 6095 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-with-literal/4") + 6096 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-with-literal/5") + 6097 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-with-literal/6") + 6098 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-with-literal/7") + 6099 # 2 * 4 bytes/elem + 4 bytes for size = offset 12 + 6100 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x0000000c) 0x00000000/r32" "F - test-convert-index-into-array-with-literal/8") + 6101 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-with-literal/9") + 6102 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-with-literal/10") + 6103 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-with-literal/11") + 6104 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-with-literal/12") + 6105 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-with-literal/13") + 6106 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-with-literal/14") + 6107 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-with-literal/15") + 6108 # . epilogue + 6109 89/<- %esp 5/r32/ebp + 6110 5d/pop-to-ebp + 6111 c3/return + 6112 + 6113 test-convert-index-into-array-of-bytes-with-literal: + 6114 # . prologue + 6115 55/push-ebp + 6116 89/<- %ebp 4/r32/esp + 6117 # setup + 6118 (clear-stream _test-input-stream) + 6119 (clear-stream $_test-input-buffered-file->buffer) + 6120 (clear-stream _test-output-stream) + 6121 (clear-stream $_test-output-buffered-file->buffer) + 6122 # + 6123 (write _test-input-stream "fn foo {\n") + 6124 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") + 6125 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n") + 6126 (write _test-input-stream "}\n") + 6127 # convert + 6128 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6129 (flush _test-output-buffered-file) + 6130 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6136 # check output + 6137 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-with-literal/0") + 6138 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-with-literal/1") + 6139 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/2") + 6140 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-with-literal/3") + 6141 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-with-literal/4") + 6142 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-with-literal/5") + 6143 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-with-literal/6") + 6144 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-with-literal/7") + 6145 # 2 * 1 byte/elem + 4 bytes for size = offset 6 + 6146 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000006) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-with-literal/8") + 6147 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-with-literal/9") + 6148 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-with-literal/10") + 6149 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-with-literal/11") + 6150 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-with-literal/12") + 6151 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-with-literal/13") + 6152 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-with-literal/14") + 6153 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-with-literal/15") + 6154 # . epilogue + 6155 89/<- %esp 5/r32/ebp + 6156 5d/pop-to-ebp + 6157 c3/return + 6158 + 6159 test-convert-index-into-array-on-stack: + 6160 # . prologue + 6161 55/push-ebp + 6162 89/<- %ebp 4/r32/esp + 6163 # setup + 6164 (clear-stream _test-input-stream) + 6165 (clear-stream $_test-input-buffered-file->buffer) + 6166 (clear-stream _test-output-stream) + 6167 (clear-stream $_test-output-buffered-file->buffer) + 6168 # + 6169 (write _test-input-stream "fn foo {\n") + 6170 (write _test-input-stream " var arr: (array int 3)\n") + 6171 (write _test-input-stream " var idx/eax: int <- copy 2\n") + 6172 (write _test-input-stream " var x/eax: (addr int) <- index arr, idx\n") + 6173 (write _test-input-stream "}\n") + 6174 # convert + 6175 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6176 (flush _test-output-buffered-file) + 6177 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6183 # check output + 6184 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack/0") + 6185 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack/1") + 6186 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack/2") + 6187 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack/3") + 6188 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack/4") + 6189 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack/5") + 6190 # var arr + 6191 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack/6") + 6192 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack/7") + 6193 # var idx + 6194 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack/8") + 6195 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 2/imm32" "F - test-convert-index-into-array-on-stack/9") + 6196 # var x is at (ebp-0x10) + idx<<2 + 4 = ebp + idx<<2 - 0xc + 6197 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + eax<<0x00000002 + 0xfffffff4) 0x00000000/r32" "F - test-convert-index-into-array-on-stack/10") + 6198 # reclaim idx + 6199 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack/11") + 6200 # reclaim arr + 6201 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack/12") + 6202 # + 6203 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack/13") + 6204 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack/14") + 6205 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack/15") + 6206 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack/16") + 6207 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack/17") + 6208 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack/18") + 6209 # . epilogue + 6210 89/<- %esp 5/r32/ebp + 6211 5d/pop-to-ebp + 6212 c3/return + 6213 + 6214 test-convert-index-into-array-on-stack-with-literal: + 6215 # . prologue + 6216 55/push-ebp + 6217 89/<- %ebp 4/r32/esp + 6218 # setup + 6219 (clear-stream _test-input-stream) + 6220 (clear-stream $_test-input-buffered-file->buffer) + 6221 (clear-stream _test-output-stream) + 6222 (clear-stream $_test-output-buffered-file->buffer) + 6223 # + 6224 (write _test-input-stream "fn foo {\n") + 6225 (write _test-input-stream " var arr: (array int 3)\n") + 6226 (write _test-input-stream " var x/eax: (addr int) <- index arr, 2\n") + 6227 (write _test-input-stream "}\n") + 6228 # convert + 6229 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6230 (flush _test-output-buffered-file) + 6231 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6237 # check output + 6238 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-on-stack-with-literal/0") + 6239 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-on-stack-with-literal/1") + 6240 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-on-stack-with-literal/2") + 6241 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-on-stack-with-literal/3") + 6242 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-on-stack-with-literal/4") + 6243 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-on-stack-with-literal/5") + 6244 # var arr + 6245 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x0000000c)" "F - test-convert-index-into-array-on-stack-with-literal/6") + 6246 (check-next-stream-line-equal _test-output-stream " 68/push 0x0000000c/imm32" "F - test-convert-index-into-array-on-stack-with-literal/7") + 6247 # var x + 6248 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-on-stack-with-literal/8") + 6249 # x is at (ebp-0x10) + 4 + 2*4 = ebp-4 + 6250 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xfffffffc) 0x00000000/r32" "F - test-convert-index-into-array-on-stack-with-literal/9") + 6251 # reclaim x + 6252 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-on-stack-with-literal/10") + 6253 # reclaim arr + 6254 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000010/imm32" "F - test-convert-index-into-array-on-stack-with-literal/11") + 6255 # + 6256 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-on-stack-with-literal/12") + 6257 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-on-stack-with-literal/13") + 6258 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-on-stack-with-literal/14") + 6259 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-on-stack-with-literal/15") + 6260 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-on-stack-with-literal/16") + 6261 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-on-stack-with-literal/17") + 6262 # . epilogue + 6263 89/<- %esp 5/r32/ebp + 6264 5d/pop-to-ebp + 6265 c3/return + 6266 + 6267 test-convert-index-into-array-of-bytes-on-stack-with-literal: + 6268 # . prologue + 6269 55/push-ebp + 6270 89/<- %ebp 4/r32/esp + 6271 # setup + 6272 (clear-stream _test-input-stream) + 6273 (clear-stream $_test-input-buffered-file->buffer) + 6274 (clear-stream _test-output-stream) + 6275 (clear-stream $_test-output-buffered-file->buffer) + 6276 # + 6277 (write _test-input-stream "fn foo {\n") + 6278 (write _test-input-stream " var arr: (array byte 3)\n") + 6279 (write _test-input-stream " var x/eax: (addr byte) <- index arr, 2\n") + 6280 (write _test-input-stream "}\n") + 6281 # convert + 6282 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6283 (flush _test-output-buffered-file) + 6284 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6290 # check output + 6291 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/0") + 6292 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/1") + 6293 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/2") + 6294 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/3") + 6295 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/4") + 6296 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/5") + 6297 # var arr + 6298 (check-next-stream-line-equal _test-output-stream " (push-n-zero-bytes 0x00000003)" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/6") + 6299 (check-next-stream-line-equal _test-output-stream " 68/push 0x00000003/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/7") + 6300 # var x + 6301 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/8") + 6302 # x is at (ebp-7) + 4 + 2 = ebp-1 + 6303 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp + 0xffffffff) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/9") + 6304 # reclaim x + 6305 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/10") + 6306 # reclaim arr + 6307 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000007/imm32" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/11") + 6308 # + 6309 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/12") + 6310 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/13") + 6311 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/14") + 6312 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/15") + 6313 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/16") + 6314 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-on-stack-with-literal/17") + 6315 # . epilogue + 6316 89/<- %esp 5/r32/ebp + 6317 5d/pop-to-ebp + 6318 c3/return + 6319 + 6320 test-convert-index-into-array-using-offset: 6321 # . prologue 6322 55/push-ebp 6323 89/<- %ebp 4/r32/esp @@ -5809,510 +5804,510 @@ if ('onhashchange' in window) { 6327 (clear-stream _test-output-stream) 6328 (clear-stream $_test-output-buffered-file->buffer) 6329 # - 6330 (write _test-input-stream "fn f {\n") - 6331 (write _test-input-stream " var a: t\n") - 6332 (write _test-input-stream " var b/eax: (addr t) <- address a\n") - 6333 (write _test-input-stream " foo b\n") - 6334 (write _test-input-stream "}\n") - 6335 (write _test-input-stream "fn foo x: (addr t) {\n") - 6336 (write _test-input-stream " var x/ecx: (addr t) <- copy x\n") - 6337 (write _test-input-stream "}\n") - 6338 (write _test-input-stream "type t {\n") - 6339 (write _test-input-stream " x: int\n") - 6340 (write _test-input-stream " y: int\n") - 6341 (write _test-input-stream "}\n") - 6342 # convert - 6343 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6344 (flush _test-output-buffered-file) - 6345 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6351 # check output - 6352 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/0") - 6353 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/1") - 6354 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/2") - 6355 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/3") - 6356 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/4") - 6357 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/5") - 6358 # var a: t - 6359 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/6") - 6360 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/7") - 6361 # var b/eax: (addr t) - 6362 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/8") - 6363 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/9") - 6364 # foo a - 6365 (check-next-stream-line-equal _test-output-stream " (foo %eax)" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/10") - 6366 # - 6367 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/11") - 6368 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/12") - 6369 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/13") - 6370 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/14") - 6371 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/15") - 6372 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/16") - 6373 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/17") - 6374 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/18") - 6375 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/19") - 6376 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/20") - 6377 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/21") - 6378 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/22") - 6379 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/23") - 6380 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/24") - 6381 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/25") - 6382 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000001/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/26") - 6383 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/27") - 6384 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/28") - 6385 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/29") - 6386 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/30") - 6387 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/31") - 6388 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/32") - 6389 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/33") - 6390 # . epilogue - 6391 89/<- %esp 5/r32/ebp - 6392 5d/pop-to-ebp - 6393 c3/return - 6394 - 6395 test-convert-get-on-local-variable: - 6396 # . prologue - 6397 55/push-ebp - 6398 89/<- %ebp 4/r32/esp - 6399 # setup - 6400 (clear-stream _test-input-stream) - 6401 (clear-stream $_test-input-buffered-file->buffer) - 6402 (clear-stream _test-output-stream) - 6403 (clear-stream $_test-output-buffered-file->buffer) - 6404 # - 6405 (write _test-input-stream "fn foo {\n") - 6406 (write _test-input-stream " var a: t\n") - 6407 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 6408 (write _test-input-stream "}\n") - 6409 (write _test-input-stream "type t {\n") - 6410 (write _test-input-stream " x: int\n") - 6411 (write _test-input-stream " y: int\n") - 6412 (write _test-input-stream "}\n") - 6413 # convert - 6414 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6415 (flush _test-output-buffered-file) - 6416 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6422 # check output - 6423 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-local-variable/0") - 6424 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-local-variable/1") - 6425 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-local-variable/2") - 6426 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-local-variable/3") - 6427 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-local-variable/4") - 6428 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-local-variable/5") - 6429 # var a - 6430 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/6") - 6431 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/7") - 6432 # var c - 6433 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-local-variable/8") - 6434 # get - 6435 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000001/r32" "F - test-convert-get-on-local-variable/9") - 6436 # reclaim c - 6437 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-local-variable/10") - 6438 # reclaim a - 6439 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-get-on-local-variable/11") - 6440 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-local-variable/12") - 6441 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-local-variable/13") - 6442 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-local-variable/14") - 6443 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-local-variable/15") - 6444 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-local-variable/16") - 6445 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-local-variable/17") - 6446 # . epilogue - 6447 89/<- %esp 5/r32/ebp - 6448 5d/pop-to-ebp - 6449 c3/return - 6450 - 6451 test-convert-get-on-function-argument: - 6452 # . prologue - 6453 55/push-ebp - 6454 89/<- %ebp 4/r32/esp - 6455 # setup - 6456 (clear-stream _test-input-stream) - 6457 (clear-stream $_test-input-buffered-file->buffer) - 6458 (clear-stream _test-output-stream) - 6459 (clear-stream $_test-output-buffered-file->buffer) - 6460 # - 6461 (write _test-input-stream "fn foo a: t {\n") - 6462 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 6463 (write _test-input-stream "}\n") - 6464 (write _test-input-stream "type t {\n") - 6465 (write _test-input-stream " x: int\n") - 6466 (write _test-input-stream " y: int\n") - 6467 (write _test-input-stream "}\n") - 6468 # convert - 6469 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6470 (flush _test-output-buffered-file) - 6471 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6477 # check output - 6478 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument/0") - 6479 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument/1") - 6480 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument/2") - 6481 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument/3") - 6482 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument/4") - 6483 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument/5") - 6484 # var c - 6485 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument/6") - 6486 # get - 6487 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument/7") - 6488 # reclaim c - 6489 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument/8") - 6490 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument/9") - 6491 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument/10") - 6492 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument/11") - 6493 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument/12") - 6494 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument/13") - 6495 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument/14") - 6496 # . epilogue - 6497 89/<- %esp 5/r32/ebp - 6498 5d/pop-to-ebp - 6499 c3/return - 6500 - 6501 test-convert-get-on-function-argument-with-known-type: - 6502 # . prologue - 6503 55/push-ebp - 6504 89/<- %ebp 4/r32/esp - 6505 # setup - 6506 (clear-stream _test-input-stream) - 6507 (clear-stream $_test-input-buffered-file->buffer) - 6508 (clear-stream _test-output-stream) - 6509 (clear-stream $_test-output-buffered-file->buffer) - 6510 # - 6511 (write _test-input-stream "type t {\n") - 6512 (write _test-input-stream " x: int\n") - 6513 (write _test-input-stream " y: int\n") - 6514 (write _test-input-stream "}\n") - 6515 (write _test-input-stream "fn foo a: t {\n") - 6516 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 6517 (write _test-input-stream "}\n") - 6518 # convert - 6519 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6520 (flush _test-output-buffered-file) - 6521 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6527 # check output - 6528 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument-with-known-type/0") - 6529 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument-with-known-type/1") - 6530 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument-with-known-type/2") - 6531 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument-with-known-type/3") - 6532 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument-with-known-type/4") - 6533 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument-with-known-type/5") - 6534 # var c - 6535 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument-with-known-type/6") - 6536 # get - 6537 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument-with-known-type/7") - 6538 # reclaim c - 6539 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument-with-known-type/8") - 6540 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument-with-known-type/9") - 6541 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument-with-known-type/10") - 6542 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument-with-known-type/11") - 6543 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument-with-known-type/12") - 6544 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument-with-known-type/13") - 6545 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument-with-known-type/14") - 6546 # . epilogue - 6547 89/<- %esp 5/r32/ebp - 6548 5d/pop-to-ebp - 6549 c3/return - 6550 - 6551 test-add-with-too-many-inouts: - 6552 # . prologue - 6553 55/push-ebp - 6554 89/<- %ebp 4/r32/esp - 6555 # setup - 6556 (clear-stream _test-input-stream) - 6557 (clear-stream $_test-input-buffered-file->buffer) - 6558 (clear-stream _test-output-stream) - 6559 (clear-stream $_test-output-buffered-file->buffer) - 6560 (clear-stream _test-error-stream) - 6561 (clear-stream $_test-error-buffered-file->buffer) - 6562 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6563 68/push 0/imm32 - 6564 68/push 0/imm32 - 6565 89/<- %edx 4/r32/esp - 6566 (tailor-exit-descriptor %edx 0x10) - 6567 # - 6568 (write _test-input-stream "fn foo {\n") - 6569 (write _test-input-stream " var a: int\n") - 6570 (write _test-input-stream " var b/ecx: int <- add a, 0\n") - 6571 (write _test-input-stream "}\n") - 6572 # convert - 6573 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6574 # registers except esp clobbered at this point - 6575 # restore ed - 6576 89/<- %edx 4/r32/esp - 6577 (flush _test-output-buffered-file) - 6578 (flush _test-error-buffered-file) - 6579 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6585 # check output - 6586 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts: output should be empty") - 6587 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts: error message") - 6588 # check that stop(1) was called - 6589 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts: exit status") - 6590 # don't restore from ebp - 6591 81 0/subop/add %esp 8/imm32 - 6592 # . epilogue - 6593 5d/pop-to-ebp - 6594 c3/return - 6595 - 6596 test-add-with-too-many-inouts-2: - 6597 # . prologue - 6598 55/push-ebp - 6599 89/<- %ebp 4/r32/esp - 6600 # setup - 6601 (clear-stream _test-input-stream) - 6602 (clear-stream $_test-input-buffered-file->buffer) - 6603 (clear-stream _test-output-stream) - 6604 (clear-stream $_test-output-buffered-file->buffer) - 6605 (clear-stream _test-error-stream) - 6606 (clear-stream $_test-error-buffered-file->buffer) - 6607 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6608 68/push 0/imm32 - 6609 68/push 0/imm32 - 6610 89/<- %edx 4/r32/esp - 6611 (tailor-exit-descriptor %edx 0x10) - 6612 # - 6613 (write _test-input-stream "fn foo {\n") - 6614 (write _test-input-stream " var a: int\n") - 6615 (write _test-input-stream " add-to a, 0, 1\n") - 6616 (write _test-input-stream "}\n") - 6617 # convert - 6618 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6619 # registers except esp clobbered at this point - 6620 # restore ed - 6621 89/<- %edx 4/r32/esp - 6622 (flush _test-output-buffered-file) - 6623 (flush _test-error-buffered-file) - 6624 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6630 # check output - 6631 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts-2: output should be empty") - 6632 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add-to: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts-2: error message") - 6633 # check that stop(1) was called - 6634 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts-2: exit status") - 6635 # don't restore from ebp - 6636 81 0/subop/add %esp 8/imm32 - 6637 # . epilogue - 6638 5d/pop-to-ebp - 6639 c3/return - 6640 - 6641 test-add-with-too-many-outputs: - 6642 # . prologue - 6643 55/push-ebp - 6644 89/<- %ebp 4/r32/esp - 6645 # setup - 6646 (clear-stream _test-input-stream) - 6647 (clear-stream $_test-input-buffered-file->buffer) - 6648 (clear-stream _test-output-stream) - 6649 (clear-stream $_test-output-buffered-file->buffer) - 6650 (clear-stream _test-error-stream) - 6651 (clear-stream $_test-error-buffered-file->buffer) - 6652 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6653 68/push 0/imm32 - 6654 68/push 0/imm32 - 6655 89/<- %edx 4/r32/esp - 6656 (tailor-exit-descriptor %edx 0x10) - 6657 # - 6658 (write _test-input-stream "fn foo {\n") - 6659 (write _test-input-stream " var a/eax: int <- copy 0\n") - 6660 (write _test-input-stream " var b/ebx: int <- copy 0\n") - 6661 (write _test-input-stream " var c/ecx: int <- copy 0\n") - 6662 (write _test-input-stream " c, b <- add a\n") - 6663 (write _test-input-stream "}\n") - 6664 # convert - 6665 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6666 # registers except esp clobbered at this point - 6667 # restore ed - 6668 89/<- %edx 4/r32/esp - 6669 (flush _test-output-buffered-file) - 6670 (flush _test-error-buffered-file) - 6671 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6677 # check output - 6678 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-outputs: output should be empty") - 6679 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many outputs; most primitives support at most one output" "F - test-add-with-too-many-outputs: error message") - 6680 # check that stop(1) was called - 6681 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-outputs: exit status") - 6682 # don't restore from ebp - 6683 81 0/subop/add %esp 8/imm32 - 6684 # . epilogue - 6685 5d/pop-to-ebp - 6686 c3/return - 6687 - 6688 test-add-with-non-number: - 6689 # . prologue - 6690 55/push-ebp - 6691 89/<- %ebp 4/r32/esp - 6692 # setup - 6693 (clear-stream _test-input-stream) - 6694 (clear-stream $_test-input-buffered-file->buffer) - 6695 (clear-stream _test-output-stream) - 6696 (clear-stream $_test-output-buffered-file->buffer) - 6697 (clear-stream _test-error-stream) - 6698 (clear-stream $_test-error-buffered-file->buffer) - 6699 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6700 68/push 0/imm32 - 6701 68/push 0/imm32 - 6702 89/<- %edx 4/r32/esp - 6703 (tailor-exit-descriptor %edx 0x10) - 6704 # - 6705 (write _test-input-stream "fn foo {\n") - 6706 (write _test-input-stream " var a: int\n") - 6707 (write _test-input-stream " var b/ecx: (addr int) <- add a\n") - 6708 (write _test-input-stream "}\n") - 6709 # convert - 6710 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6711 # registers except esp clobbered at this point - 6712 # restore ed - 6713 89/<- %edx 4/r32/esp - 6714 (flush _test-output-buffered-file) - 6715 (flush _test-error-buffered-file) - 6716 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6722 # check output - 6723 (check-stream-equal _test-output-stream "" "F - test-add-with-non-number: output should be empty") - 6724 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: 'b' must be a non-addr non-offset scalar" "F - test-add-with-non-number: error message") - 6725 # check that stop(1) was called - 6726 (check-ints-equal *(edx+4) 2 "F - test-add-with-non-number: exit status") - 6727 # don't restore from ebp - 6728 81 0/subop/add %esp 8/imm32 - 6729 # . epilogue - 6730 5d/pop-to-ebp - 6731 c3/return - 6732 - 6733 test-add-with-addr-dereferenced: - 6734 # . prologue - 6735 55/push-ebp - 6736 89/<- %ebp 4/r32/esp - 6737 # setup - 6738 (clear-stream _test-input-stream) - 6739 (clear-stream $_test-input-buffered-file->buffer) - 6740 (clear-stream _test-output-stream) - 6741 (clear-stream $_test-output-buffered-file->buffer) - 6742 # - 6743 (write _test-input-stream "fn foo {\n") - 6744 (write _test-input-stream " var a/eax: (addr int) <- copy 0\n") - 6745 (write _test-input-stream " add-to *a, 1\n") - 6746 (write _test-input-stream "}\n") - 6747 # convert - 6748 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6749 (flush _test-output-buffered-file) - 6750 # no error - 6751 # . epilogue - 6752 89/<- %esp 5/r32/ebp - 6753 5d/pop-to-ebp - 6754 c3/return - 6755 - 6756 test-copy-with-no-inout: - 6757 # . prologue - 6758 55/push-ebp - 6759 89/<- %ebp 4/r32/esp - 6760 # setup - 6761 (clear-stream _test-input-stream) - 6762 (clear-stream $_test-input-buffered-file->buffer) - 6763 (clear-stream _test-output-stream) - 6764 (clear-stream $_test-output-buffered-file->buffer) - 6765 (clear-stream _test-error-stream) - 6766 (clear-stream $_test-error-buffered-file->buffer) - 6767 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6768 68/push 0/imm32 - 6769 68/push 0/imm32 - 6770 89/<- %edx 4/r32/esp - 6771 (tailor-exit-descriptor %edx 0x10) - 6772 # - 6773 (write _test-input-stream "fn foo {\n") - 6774 (write _test-input-stream " var x/eax: boolean <- copy\n") + 6330 (write _test-input-stream "fn foo {\n") + 6331 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 6332 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 6333 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n") + 6334 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n") + 6335 (write _test-input-stream "}\n") + 6336 # convert + 6337 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6338 (flush _test-output-buffered-file) + 6339 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6345 # check output + 6346 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset/0") + 6347 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset/1") + 6348 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset/2") + 6349 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset/3") + 6350 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset/4") + 6351 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset/5") + 6352 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset/6") + 6353 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset/7") + 6354 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset/8") + 6355 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-using-offset/9") + 6356 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset/10") + 6357 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset/11") + 6358 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset/12") + 6359 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset/13") + 6360 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset/14") + 6361 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset/15") + 6362 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset/16") + 6363 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset/17") + 6364 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset/18") + 6365 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset/19") + 6366 # . epilogue + 6367 89/<- %esp 5/r32/ebp + 6368 5d/pop-to-ebp + 6369 c3/return + 6370 + 6371 test-convert-index-into-array-of-bytes-using-offset: + 6372 # . prologue + 6373 55/push-ebp + 6374 89/<- %ebp 4/r32/esp + 6375 # setup + 6376 (clear-stream _test-input-stream) + 6377 (clear-stream $_test-input-buffered-file->buffer) + 6378 (clear-stream _test-output-stream) + 6379 (clear-stream $_test-output-buffered-file->buffer) + 6380 # + 6381 (write _test-input-stream "fn foo {\n") + 6382 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") + 6383 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 6384 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n") + 6385 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n") + 6386 (write _test-input-stream "}\n") + 6387 # convert + 6388 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6389 (flush _test-output-buffered-file) + 6390 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6396 # check output + 6397 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset/0") + 6398 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset/1") + 6399 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/2") + 6400 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset/3") + 6401 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset/4") + 6402 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset/5") + 6403 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset/6") + 6404 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/7") + 6405 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/8") + 6406 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-index-into-array-of-bytes-using-offset/9") + 6407 (check-next-stream-line-equal _test-output-stream " 69/multiply %ecx 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset/10") + 6408 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset/11") + 6409 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset/12") + 6410 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset/13") + 6411 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset/14") + 6412 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset/15") + 6413 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset/16") + 6414 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset/17") + 6415 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset/18") + 6416 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset/19") + 6417 # . epilogue + 6418 89/<- %esp 5/r32/ebp + 6419 5d/pop-to-ebp + 6420 c3/return + 6421 + 6422 test-convert-index-into-array-using-offset-on-stack: + 6423 # . prologue + 6424 55/push-ebp + 6425 89/<- %ebp 4/r32/esp + 6426 # setup + 6427 (clear-stream _test-input-stream) + 6428 (clear-stream $_test-input-buffered-file->buffer) + 6429 (clear-stream _test-output-stream) + 6430 (clear-stream $_test-output-buffered-file->buffer) + 6431 # + 6432 (write _test-input-stream "fn foo {\n") + 6433 (write _test-input-stream " var arr/eax: (addr array int) <- copy 0\n") + 6434 (write _test-input-stream " var idx: int\n") + 6435 (write _test-input-stream " var off/ecx: (offset int) <- compute-offset arr, idx\n") + 6436 (write _test-input-stream " var x/eax: (addr int) <- index arr, off\n") + 6437 (write _test-input-stream "}\n") + 6438 # convert + 6439 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6440 (flush _test-output-buffered-file) + 6441 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6447 # check output + 6448 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-using-offset-on-stack/0") + 6449 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-using-offset-on-stack/1") + 6450 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-using-offset-on-stack/2") + 6451 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-using-offset-on-stack/3") + 6452 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-using-offset-on-stack/4") + 6453 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-using-offset-on-stack/5") + 6454 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-using-offset-on-stack/6") + 6455 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/7") + 6456 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-using-offset-on-stack/8") + 6457 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-using-offset-on-stack/9") + 6458 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000004/imm32 0x00000001/r32" "F - test-convert-index-into-array-using-offset-on-stack/10") + 6459 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-using-offset-on-stack/11") + 6460 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-using-offset-on-stack/12") + 6461 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-using-offset-on-stack/13") + 6462 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-using-offset-on-stack/14") + 6463 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-using-offset-on-stack/15") + 6464 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-using-offset-on-stack/16") + 6465 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-using-offset-on-stack/17") + 6466 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-using-offset-on-stack/18") + 6467 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-using-offset-on-stack/19") + 6468 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-using-offset-on-stack/20") + 6469 # . epilogue + 6470 89/<- %esp 5/r32/ebp + 6471 5d/pop-to-ebp + 6472 c3/return + 6473 + 6474 test-convert-index-into-array-of-bytes-using-offset-on-stack: + 6475 # . prologue + 6476 55/push-ebp + 6477 89/<- %ebp 4/r32/esp + 6478 # setup + 6479 (clear-stream _test-input-stream) + 6480 (clear-stream $_test-input-buffered-file->buffer) + 6481 (clear-stream _test-output-stream) + 6482 (clear-stream $_test-output-buffered-file->buffer) + 6483 # + 6484 (write _test-input-stream "fn foo {\n") + 6485 (write _test-input-stream " var arr/eax: (addr array byte) <- copy 0\n") + 6486 (write _test-input-stream " var idx: int\n") + 6487 (write _test-input-stream " var off/ecx: (offset byte) <- compute-offset arr, idx\n") + 6488 (write _test-input-stream " var x/eax: (addr byte) <- index arr, off\n") + 6489 (write _test-input-stream "}\n") + 6490 # convert + 6491 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6492 (flush _test-output-buffered-file) + 6493 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6499 # check output + 6500 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/0") + 6501 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/1") + 6502 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/2") + 6503 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/3") + 6504 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/4") + 6505 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/5") + 6506 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/6") + 6507 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/7") + 6508 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/8") + 6509 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/9") + 6510 (check-next-stream-line-equal _test-output-stream " 69/multiply *(ebp+0xfffffff8) 0x00000001/imm32 0x00000001/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/10") + 6511 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx + 4) 0x00000000/r32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/11") + 6512 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/12") + 6513 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/13") + 6514 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/14") + 6515 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/15") + 6516 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/16") + 6517 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/17") + 6518 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/18") + 6519 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/19") + 6520 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-index-into-array-of-bytes-using-offset-on-stack/20") + 6521 # . epilogue + 6522 89/<- %esp 5/r32/ebp + 6523 5d/pop-to-ebp + 6524 c3/return + 6525 + 6526 test-convert-function-and-type-definition: + 6527 # . prologue + 6528 55/push-ebp + 6529 89/<- %ebp 4/r32/esp + 6530 # setup + 6531 (clear-stream _test-input-stream) + 6532 (clear-stream $_test-input-buffered-file->buffer) + 6533 (clear-stream _test-output-stream) + 6534 (clear-stream $_test-output-buffered-file->buffer) + 6535 # + 6536 (write _test-input-stream "fn foo a: (addr t) {\n") + 6537 (write _test-input-stream " var _a/eax: (addr t) <- copy a\n") + 6538 (write _test-input-stream " var b/ecx: (addr int) <- get _a, x\n") + 6539 (write _test-input-stream " var c/ecx: (addr int) <- get _a, y\n") + 6540 (write _test-input-stream "}\n") + 6541 (write _test-input-stream "type t {\n") + 6542 (write _test-input-stream " x: int\n") + 6543 (write _test-input-stream " y: int\n") + 6544 (write _test-input-stream "}\n") + 6545 # convert + 6546 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6547 (flush _test-output-buffered-file) + 6548 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6554 # check output + 6555 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-and-type-definition/0") + 6556 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-and-type-definition/1") + 6557 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-and-type-definition/2") + 6558 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-and-type-definition/3") + 6559 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-and-type-definition/4") + 6560 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-and-type-definition/5") + 6561 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-and-type-definition/6") + 6562 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000000/r32" "F - test-convert-function-and-type-definition/7") + 6563 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-and-type-definition/8") + 6564 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000000) 0x00000001/r32" "F - test-convert-function-and-type-definition/9") + 6565 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + 0x00000004) 0x00000001/r32" "F - test-convert-function-and-type-definition/11") + 6566 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-and-type-definition/13") + 6567 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-and-type-definition/14") + 6568 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-and-type-definition/15") + 6569 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-and-type-definition/16") + 6570 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-and-type-definition/17") + 6571 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-and-type-definition/18") + 6572 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-and-type-definition/19") + 6573 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-and-type-definition/20") + 6574 # . epilogue + 6575 89/<- %esp 5/r32/ebp + 6576 5d/pop-to-ebp + 6577 c3/return + 6578 + 6579 test-type-definition-with-array: + 6580 # . prologue + 6581 55/push-ebp + 6582 89/<- %ebp 4/r32/esp + 6583 # setup + 6584 (clear-stream _test-input-stream) + 6585 (clear-stream $_test-input-buffered-file->buffer) + 6586 (clear-stream _test-output-stream) + 6587 (clear-stream $_test-output-buffered-file->buffer) + 6588 (clear-stream _test-error-stream) + 6589 (clear-stream $_test-error-buffered-file->buffer) + 6590 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 6591 68/push 0/imm32 + 6592 68/push 0/imm32 + 6593 89/<- %edx 4/r32/esp + 6594 (tailor-exit-descriptor %edx 0x10) + 6595 # + 6596 (write _test-input-stream "type t {\n") + 6597 (write _test-input-stream " a: (array int 3)\n") + 6598 (write _test-input-stream "}\n") + 6599 # convert + 6600 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 6601 # registers except esp clobbered at this point + 6602 # restore ed + 6603 89/<- %edx 4/r32/esp + 6604 (flush _test-output-buffered-file) + 6605 (flush _test-error-buffered-file) + 6606 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6612 # check output + 6613 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-array: output should be empty") + 6614 (check-next-stream-line-equal _test-error-stream "type t: 'array' elements not allowed for now" "F - test-type-definition-with-array: error message") + 6615 # check that stop(1) was called + 6616 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-array: exit status") + 6617 # don't restore from ebp + 6618 81 0/subop/add %esp 8/imm32 + 6619 # . epilogue + 6620 5d/pop-to-ebp + 6621 c3/return + 6622 + 6623 test-type-definition-with-addr: + 6624 # . prologue + 6625 55/push-ebp + 6626 89/<- %ebp 4/r32/esp + 6627 # setup + 6628 (clear-stream _test-input-stream) + 6629 (clear-stream $_test-input-buffered-file->buffer) + 6630 (clear-stream _test-output-stream) + 6631 (clear-stream $_test-output-buffered-file->buffer) + 6632 (clear-stream _test-error-stream) + 6633 (clear-stream $_test-error-buffered-file->buffer) + 6634 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 6635 68/push 0/imm32 + 6636 68/push 0/imm32 + 6637 89/<- %edx 4/r32/esp + 6638 (tailor-exit-descriptor %edx 0x10) + 6639 # + 6640 (write _test-input-stream "type t {\n") + 6641 (write _test-input-stream " a: (addr int)\n") + 6642 (write _test-input-stream "}\n") + 6643 # convert + 6644 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 6645 # registers except esp clobbered at this point + 6646 # restore ed + 6647 89/<- %edx 4/r32/esp + 6648 (flush _test-output-buffered-file) + 6649 (flush _test-error-buffered-file) + 6650 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6656 # check output + 6657 (check-stream-equal _test-output-stream "" "F - test-type-definition-with-addr: output should be empty") + 6658 (check-next-stream-line-equal _test-error-stream "type t: 'addr' elements not allowed" "F - test-type-definition-with-addr: error message") + 6659 # check that stop(1) was called + 6660 (check-ints-equal *(edx+4) 2 "F - test-type-definition-with-addr: exit status") + 6661 # don't restore from ebp + 6662 81 0/subop/add %esp 8/imm32 + 6663 # . epilogue + 6664 5d/pop-to-ebp + 6665 c3/return + 6666 + 6667 test-convert-function-with-local-var-with-user-defined-type: + 6668 # . prologue + 6669 55/push-ebp + 6670 89/<- %ebp 4/r32/esp + 6671 # setup + 6672 (clear-stream _test-input-stream) + 6673 (clear-stream $_test-input-buffered-file->buffer) + 6674 (clear-stream _test-output-stream) + 6675 (clear-stream $_test-output-buffered-file->buffer) + 6676 # + 6677 (write _test-input-stream "fn foo {\n") + 6678 (write _test-input-stream " var a: t\n") + 6679 (write _test-input-stream "}\n") + 6680 (write _test-input-stream "type t {\n") + 6681 (write _test-input-stream " x: int\n") + 6682 (write _test-input-stream " y: int\n") + 6683 (write _test-input-stream "}\n") + 6684 # convert + 6685 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6686 (flush _test-output-buffered-file) + 6687 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6693 # check output + 6694 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type/0") + 6695 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type/1") + 6696 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/2") + 6697 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-user-defined-type/3") + 6698 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-user-defined-type/4") + 6699 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-user-defined-type/5") + 6700 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/6") + 6701 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/7") + 6702 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-with-local-var-with-user-defined-type/8") + 6703 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-user-defined-type/9") + 6704 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-user-defined-type/10") + 6705 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-user-defined-type/11") + 6706 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-user-defined-type/12") + 6707 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-user-defined-type/13") + 6708 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-user-defined-type/14") + 6709 # . epilogue + 6710 89/<- %esp 5/r32/ebp + 6711 5d/pop-to-ebp + 6712 c3/return + 6713 + 6714 test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type: + 6715 # . prologue + 6716 55/push-ebp + 6717 89/<- %ebp 4/r32/esp + 6718 # setup + 6719 (clear-stream _test-input-stream) + 6720 (clear-stream $_test-input-buffered-file->buffer) + 6721 (clear-stream _test-output-stream) + 6722 (clear-stream $_test-output-buffered-file->buffer) + 6723 # + 6724 (write _test-input-stream "fn foo {\n") + 6725 (write _test-input-stream " var a: t\n") + 6726 (write _test-input-stream "}\n") + 6727 (write _test-input-stream "type t {\n") + 6728 (write _test-input-stream " x: s\n") + 6729 (write _test-input-stream "}\n") + 6730 (write _test-input-stream "type s {\n") + 6731 (write _test-input-stream " z: int\n") + 6732 (write _test-input-stream "}\n") + 6733 # convert + 6734 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6735 (flush _test-output-buffered-file) + 6736 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6742 # check output + 6743 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/0") + 6744 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/1") + 6745 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/2") + 6746 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/3") + 6747 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/4") + 6748 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/5") + 6749 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/7") + 6750 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/8") + 6751 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/9") + 6752 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/10") + 6753 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/11") + 6754 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/12") + 6755 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/13") + 6756 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-local-var-with-user-defined-type-containing-user-defined-type/14") + 6757 # . epilogue + 6758 89/<- %esp 5/r32/ebp + 6759 5d/pop-to-ebp + 6760 c3/return + 6761 + 6762 test-convert-function-call-with-arg-of-user-defined-type: + 6763 # . prologue + 6764 55/push-ebp + 6765 89/<- %ebp 4/r32/esp + 6766 # setup + 6767 (clear-stream _test-input-stream) + 6768 (clear-stream $_test-input-buffered-file->buffer) + 6769 (clear-stream _test-output-stream) + 6770 (clear-stream $_test-output-buffered-file->buffer) + 6771 # + 6772 (write _test-input-stream "fn f {\n") + 6773 (write _test-input-stream " var a: t\n") + 6774 (write _test-input-stream " foo a\n") 6775 (write _test-input-stream "}\n") - 6776 # convert - 6777 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6778 # registers except esp clobbered at this point - 6779 # restore ed - 6780 89/<- %edx 4/r32/esp - 6781 (flush _test-output-buffered-file) - 6782 (flush _test-error-buffered-file) - 6783 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6789 # check output - 6790 (check-stream-equal _test-output-stream "" "F - test-copy-with-no-inout: output should be empty") - 6791 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' expects an inout" "F - test-copy-with-no-inout: error message") - 6792 # check that stop(1) was called - 6793 (check-ints-equal *(edx+4) 2 "F - test-copy-with-no-inout: exit status") - 6794 # don't restore from ebp - 6795 81 0/subop/add %esp 8/imm32 - 6796 # . epilogue - 6797 5d/pop-to-ebp - 6798 c3/return - 6799 - 6800 test-copy-with-multiple-inouts: - 6801 # . prologue - 6802 55/push-ebp - 6803 89/<- %ebp 4/r32/esp - 6804 # setup - 6805 (clear-stream _test-input-stream) - 6806 (clear-stream $_test-input-buffered-file->buffer) - 6807 (clear-stream _test-output-stream) - 6808 (clear-stream $_test-output-buffered-file->buffer) - 6809 (clear-stream _test-error-stream) - 6810 (clear-stream $_test-error-buffered-file->buffer) - 6811 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6812 68/push 0/imm32 - 6813 68/push 0/imm32 - 6814 89/<- %edx 4/r32/esp - 6815 (tailor-exit-descriptor %edx 0x10) - 6816 # - 6817 (write _test-input-stream "fn foo {\n") - 6818 (write _test-input-stream " var x/eax: boolean <- copy 0, 0\n") - 6819 (write _test-input-stream "}\n") - 6820 # convert - 6821 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6822 # registers except esp clobbered at this point - 6823 # restore ed - 6824 89/<- %edx 4/r32/esp - 6825 (flush _test-output-buffered-file) - 6826 (flush _test-error-buffered-file) - 6827 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6833 # check output - 6834 (check-stream-equal _test-output-stream "" "F - test-copy-with-multiple-inouts: output should be empty") - 6835 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' must have just one inout" "F - test-copy-with-multiple-inouts: error message") - 6836 # check that stop(1) was called - 6837 (check-ints-equal *(edx+4) 2 "F - test-copy-with-multiple-inouts: exit status") - 6838 # don't restore from ebp - 6839 81 0/subop/add %esp 8/imm32 - 6840 # . epilogue - 6841 5d/pop-to-ebp - 6842 c3/return - 6843 - 6844 test-copy-with-no-output: - 6845 # . prologue - 6846 55/push-ebp - 6847 89/<- %ebp 4/r32/esp - 6848 # setup - 6849 (clear-stream _test-input-stream) - 6850 (clear-stream $_test-input-buffered-file->buffer) - 6851 (clear-stream _test-output-stream) - 6852 (clear-stream $_test-output-buffered-file->buffer) - 6853 (clear-stream _test-error-stream) - 6854 (clear-stream $_test-error-buffered-file->buffer) - 6855 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6856 68/push 0/imm32 - 6857 68/push 0/imm32 - 6858 89/<- %edx 4/r32/esp - 6859 (tailor-exit-descriptor %edx 0x10) - 6860 # - 6861 (write _test-input-stream "fn foo {\n") - 6862 (write _test-input-stream " copy 0\n") - 6863 (write _test-input-stream "}\n") - 6864 # convert - 6865 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6866 # registers except esp clobbered at this point - 6867 # restore ed - 6868 89/<- %edx 4/r32/esp - 6869 (flush _test-output-buffered-file) - 6870 (flush _test-error-buffered-file) - 6871 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6877 # check output - 6878 (check-stream-equal _test-output-stream "" "F - test-copy-with-no-output: output should be empty") - 6879 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' expects an output" "F - test-copy-with-no-output: error message") - 6880 # check that stop(1) was called - 6881 (check-ints-equal *(edx+4) 2 "F - test-copy-with-no-output: exit status") - 6882 # don't restore from ebp - 6883 81 0/subop/add %esp 8/imm32 - 6884 # . epilogue - 6885 5d/pop-to-ebp - 6886 c3/return - 6887 - 6888 test-copy-with-multiple-outputs: + 6776 (write _test-input-stream "fn foo x: t {\n") + 6777 (write _test-input-stream "}\n") + 6778 (write _test-input-stream "type t {\n") + 6779 (write _test-input-stream " x: int\n") + 6780 (write _test-input-stream " y: int\n") + 6781 (write _test-input-stream "}\n") + 6782 # convert + 6783 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6784 (flush _test-output-buffered-file) + 6785 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6791 # check output + 6792 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") + 6793 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") + 6794 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2") + 6795 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3") + 6796 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4") + 6797 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5") + 6798 # var a: t + 6799 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/6") + 6800 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7") + 6801 # foo a + 6802 (check-next-stream-line-equal _test-output-stream " (foo *(ebp+0xfffffff8) *(ebp+0xfffffffc))" "F - test-convert-function-call-with-arg-of-user-defined-type/8") + 6803 # + 6804 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/9") + 6805 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10") + 6806 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11") + 6807 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12") + 6808 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13") + 6809 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14") + 6810 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15") + 6811 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16") + 6812 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17") + 6813 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18") + 6814 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19") + 6815 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20") + 6816 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21") + 6817 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22") + 6818 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23") + 6819 # . epilogue + 6820 89/<- %esp 5/r32/ebp + 6821 5d/pop-to-ebp + 6822 c3/return + 6823 + 6824 test-convert-function-call-with-arg-of-user-defined-type-register-indirect: + 6825 # . prologue + 6826 55/push-ebp + 6827 89/<- %ebp 4/r32/esp + 6828 # setup + 6829 (clear-stream _test-input-stream) + 6830 (clear-stream $_test-input-buffered-file->buffer) + 6831 (clear-stream _test-output-stream) + 6832 (clear-stream $_test-output-buffered-file->buffer) + 6833 # + 6834 (write _test-input-stream "fn f {\n") + 6835 (write _test-input-stream " var a/eax: (addr t) <- copy 0\n") + 6836 (write _test-input-stream " foo *a\n") + 6837 (write _test-input-stream "}\n") + 6838 (write _test-input-stream "fn foo x: t {\n") + 6839 (write _test-input-stream "}\n") + 6840 (write _test-input-stream "type t {\n") + 6841 (write _test-input-stream " x: int\n") + 6842 (write _test-input-stream " y: int\n") + 6843 (write _test-input-stream "}\n") + 6844 # convert + 6845 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6846 (flush _test-output-buffered-file) + 6847 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6853 # check output + 6854 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type/0") + 6855 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/1") + 6856 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/2") + 6857 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/3") + 6858 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type/4") + 6859 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type/5") + 6860 # var a + 6861 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/6") + 6862 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type/7") + 6863 # foo a + 6864 (check-next-stream-line-equal _test-output-stream " (foo *(eax+0x00000000) *(eax+0x00000004))" "F - test-convert-function-call-with-arg-of-user-defined-type/8") + 6865 # + 6866 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type/9") + 6867 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type/10") + 6868 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type/11") + 6869 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/12") + 6870 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/13") + 6871 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/14") + 6872 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/15") + 6873 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type/16") + 6874 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type/17") + 6875 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/18") + 6876 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type/19") + 6877 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type/20") + 6878 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/21") + 6879 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type/22") + 6880 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type/23") + 6881 # . epilogue + 6882 89/<- %esp 5/r32/ebp + 6883 5d/pop-to-ebp + 6884 c3/return + 6885 + 6886 # we don't have special support for call-by-reference; just explicitly create + 6887 # a new variable with the address of the arg + 6888 test-convert-function-call-with-arg-of-user-defined-type-by-reference: 6889 # . prologue 6890 55/push-ebp 6891 89/<- %ebp 4/r32/esp @@ -6321,577 +6316,592 @@ if ('onhashchange' in window) { 6894 (clear-stream $_test-input-buffered-file->buffer) 6895 (clear-stream _test-output-stream) 6896 (clear-stream $_test-output-buffered-file->buffer) - 6897 (clear-stream _test-error-stream) - 6898 (clear-stream $_test-error-buffered-file->buffer) - 6899 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6900 68/push 0/imm32 - 6901 68/push 0/imm32 - 6902 89/<- %edx 4/r32/esp - 6903 (tailor-exit-descriptor %edx 0x10) - 6904 # - 6905 (write _test-input-stream "fn foo {\n") - 6906 (write _test-input-stream " var x/eax: boolean <- copy 0\n") - 6907 (write _test-input-stream " var y/ecx: boolean <- copy 0\n") - 6908 (write _test-input-stream " x, y <- copy 0\n") + 6897 # + 6898 (write _test-input-stream "fn f {\n") + 6899 (write _test-input-stream " var a: t\n") + 6900 (write _test-input-stream " var b/eax: (addr t) <- address a\n") + 6901 (write _test-input-stream " foo b\n") + 6902 (write _test-input-stream "}\n") + 6903 (write _test-input-stream "fn foo x: (addr t) {\n") + 6904 (write _test-input-stream " var x/ecx: (addr t) <- copy x\n") + 6905 (write _test-input-stream "}\n") + 6906 (write _test-input-stream "type t {\n") + 6907 (write _test-input-stream " x: int\n") + 6908 (write _test-input-stream " y: int\n") 6909 (write _test-input-stream "}\n") 6910 # convert - 6911 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6912 # registers except esp clobbered at this point - 6913 # restore ed - 6914 89/<- %edx 4/r32/esp - 6915 (flush _test-output-buffered-file) - 6916 (flush _test-error-buffered-file) - 6917 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6923 # check output - 6924 (check-stream-equal _test-output-stream "" "F - test-copy-with-multiple-outputs: output should be empty") - 6925 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' must have just one output" "F - test-copy-with-multiple-outputs: error message") - 6926 # check that stop(1) was called - 6927 (check-ints-equal *(edx+4) 2 "F - test-copy-with-multiple-outputs: exit status") - 6928 # don't restore from ebp - 6929 81 0/subop/add %esp 8/imm32 - 6930 # . epilogue - 6931 5d/pop-to-ebp - 6932 c3/return - 6933 - 6934 test-copy-invalid-value-to-address: - 6935 # . prologue - 6936 55/push-ebp - 6937 89/<- %ebp 4/r32/esp - 6938 # setup - 6939 (clear-stream _test-input-stream) - 6940 (clear-stream $_test-input-buffered-file->buffer) - 6941 (clear-stream _test-output-stream) - 6942 (clear-stream $_test-output-buffered-file->buffer) - 6943 (clear-stream _test-error-stream) - 6944 (clear-stream $_test-error-buffered-file->buffer) - 6945 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 6946 68/push 0/imm32 - 6947 68/push 0/imm32 - 6948 89/<- %edx 4/r32/esp - 6949 (tailor-exit-descriptor %edx 0x10) - 6950 # - 6951 (write _test-input-stream "fn foo {\n") - 6952 (write _test-input-stream " var x/eax: int <- copy 0\n") - 6953 (write _test-input-stream " var y/ecx: (addr int) <- copy x\n") - 6954 (write _test-input-stream "}\n") - 6955 # convert - 6956 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 6957 # registers except esp clobbered at this point - 6958 # restore ed - 6959 89/<- %edx 4/r32/esp - 6960 (flush _test-output-buffered-file) - 6961 (flush _test-error-buffered-file) - 6962 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 6968 # check output - 6969 (check-stream-equal _test-output-stream "" "F - test-copy-invalid-value-to-address: output should be empty") - 6970 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: 'y' must be a non-addr non-offset scalar" "F - test-copy-invalid-value-to-address: error message") - 6971 # check that stop(1) was called - 6972 (check-ints-equal *(edx+4) 2 "F - test-copy-invalid-value-to-address: exit status") - 6973 # don't restore from ebp - 6974 81 0/subop/add %esp 8/imm32 - 6975 # . epilogue - 6976 5d/pop-to-ebp - 6977 c3/return - 6978 - 6979 test-copy-null-value-to-addr: - 6980 # . prologue - 6981 55/push-ebp - 6982 89/<- %ebp 4/r32/esp - 6983 # setup - 6984 (clear-stream _test-input-stream) - 6985 (clear-stream $_test-input-buffered-file->buffer) - 6986 (clear-stream _test-output-stream) - 6987 (clear-stream $_test-output-buffered-file->buffer) - 6988 # - 6989 (write _test-input-stream "fn foo {\n") - 6990 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") - 6991 (write _test-input-stream "}\n") - 6992 # convert - 6993 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 6994 (flush _test-output-buffered-file) - 6995 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7001 # no errors - 7002 # . epilogue - 7003 89/<- %esp 5/r32/ebp - 7004 5d/pop-to-ebp - 7005 c3/return - 7006 - 7007 test-copy-invalid-value-to-offset: - 7008 # . prologue - 7009 55/push-ebp - 7010 89/<- %ebp 4/r32/esp - 7011 # setup - 7012 (clear-stream _test-input-stream) - 7013 (clear-stream $_test-input-buffered-file->buffer) - 7014 (clear-stream _test-output-stream) - 7015 (clear-stream $_test-output-buffered-file->buffer) - 7016 (clear-stream _test-error-stream) - 7017 (clear-stream $_test-error-buffered-file->buffer) - 7018 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7019 68/push 0/imm32 - 7020 68/push 0/imm32 - 7021 89/<- %edx 4/r32/esp - 7022 (tailor-exit-descriptor %edx 0x10) - 7023 # - 7024 (write _test-input-stream "fn foo {\n") - 7025 (write _test-input-stream " var x/eax: int <- copy 0\n") - 7026 (write _test-input-stream " var y/ecx: (offset int) <- copy x\n") - 7027 (write _test-input-stream "}\n") - 7028 # convert - 7029 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7030 # registers except esp clobbered at this point - 7031 # restore ed - 7032 89/<- %edx 4/r32/esp - 7033 (flush _test-output-buffered-file) - 7034 (flush _test-error-buffered-file) - 7035 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7041 # check output - 7042 (check-stream-equal _test-output-stream "" "F - test-copy-invalid-value-to-address: output should be empty") - 7043 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: 'y' must be a non-addr non-offset scalar" "F - test-copy-invalid-value-to-address: error message") - 7044 # check that stop(1) was called - 7045 (check-ints-equal *(edx+4) 2 "F - test-copy-invalid-value-to-offset: exit status") - 7046 # don't restore from ebp - 7047 81 0/subop/add %esp 8/imm32 - 7048 # . epilogue - 7049 5d/pop-to-ebp - 7050 c3/return - 7051 - 7052 test-copy-null-value-to-offset: - 7053 # . prologue - 7054 55/push-ebp - 7055 89/<- %ebp 4/r32/esp - 7056 # setup - 7057 (clear-stream _test-input-stream) - 7058 (clear-stream $_test-input-buffered-file->buffer) - 7059 (clear-stream _test-output-stream) - 7060 (clear-stream $_test-output-buffered-file->buffer) - 7061 # - 7062 (write _test-input-stream "fn foo {\n") - 7063 (write _test-input-stream " var y/ecx: (offset int) <- copy 0\n") - 7064 (write _test-input-stream "}\n") - 7065 # convert - 7066 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 7067 (flush _test-output-buffered-file) - 7068 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7074 # no errors - 7075 # . epilogue - 7076 89/<- %esp 5/r32/ebp - 7077 5d/pop-to-ebp - 7078 c3/return - 7079 - 7080 test-copy-deref-address: - 7081 # . prologue - 7082 55/push-ebp - 7083 89/<- %ebp 4/r32/esp - 7084 # setup - 7085 (clear-stream _test-input-stream) - 7086 (clear-stream $_test-input-buffered-file->buffer) - 7087 (clear-stream _test-output-stream) - 7088 (clear-stream $_test-output-buffered-file->buffer) - 7089 # - 7090 (write _test-input-stream "fn foo {\n") - 7091 (write _test-input-stream " var x/eax: (addr addr int) <- copy 0\n") - 7092 (write _test-input-stream " var y/ecx: (addr int) <- copy *x\n") - 7093 (write _test-input-stream "}\n") - 7094 # convert - 7095 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 7096 (flush _test-output-buffered-file) - 7097 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7103 # not bothering checking output - 7104 (check-next-stream-line-equal _test-error-stream "" "F - test-copy-deref-address: error message") - 7105 # . epilogue - 7106 5d/pop-to-ebp - 7107 c3/return - 7108 - 7109 test-copy-to-non-register: - 7110 # . prologue - 7111 55/push-ebp - 7112 89/<- %ebp 4/r32/esp - 7113 # setup - 7114 (clear-stream _test-input-stream) - 7115 (clear-stream $_test-input-buffered-file->buffer) - 7116 (clear-stream _test-output-stream) - 7117 (clear-stream $_test-output-buffered-file->buffer) - 7118 (clear-stream _test-error-stream) - 7119 (clear-stream $_test-error-buffered-file->buffer) - 7120 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7121 68/push 0/imm32 - 7122 68/push 0/imm32 - 7123 89/<- %edx 4/r32/esp - 7124 (tailor-exit-descriptor %edx 0x10) - 7125 # - 7126 (write _test-input-stream "fn foo {\n") - 7127 (write _test-input-stream " var x: int\n") - 7128 (write _test-input-stream " x <- copy 0\n") - 7129 (write _test-input-stream "}\n") - 7130 # convert - 7131 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7132 # registers except esp clobbered at this point - 7133 # restore ed - 7134 89/<- %edx 4/r32/esp - 7135 (flush _test-output-buffered-file) - 7136 (flush _test-error-buffered-file) - 7137 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7143 # check output - 7144 (check-stream-equal _test-output-stream "" "F - test-copy-to-non-register: output should be empty") - 7145 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: output 'x' not in a register" "F - test-copy-to-non-register: error message") - 7146 # check that stop(1) was called - 7147 (check-ints-equal *(edx+4) 2 "F - test-copy-to-non-register: exit status") - 7148 # don't restore from ebp - 7149 81 0/subop/add %esp 8/imm32 - 7150 # . epilogue - 7151 5d/pop-to-ebp - 7152 c3/return - 7153 - 7154 test-copy-non-scalar: - 7155 # . prologue - 7156 55/push-ebp - 7157 89/<- %ebp 4/r32/esp - 7158 # setup - 7159 (clear-stream _test-input-stream) - 7160 (clear-stream $_test-input-buffered-file->buffer) - 7161 (clear-stream _test-output-stream) - 7162 (clear-stream $_test-output-buffered-file->buffer) - 7163 (clear-stream _test-error-stream) - 7164 (clear-stream $_test-error-buffered-file->buffer) - 7165 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7166 68/push 0/imm32 - 7167 68/push 0/imm32 - 7168 89/<- %edx 4/r32/esp - 7169 (tailor-exit-descriptor %edx 0x10) - 7170 # - 7171 (write _test-input-stream "fn foo {\n") - 7172 (write _test-input-stream " var x: (handle int)\n") - 7173 (write _test-input-stream " var y/eax: int <- copy x\n") - 7174 (write _test-input-stream "}\n") - 7175 # convert - 7176 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7177 # registers except esp clobbered at this point - 7178 # restore ed - 7179 89/<- %edx 4/r32/esp - 7180 (flush _test-output-buffered-file) - 7181 (flush _test-error-buffered-file) - 7182 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7188 # check output - 7189 (check-stream-equal _test-output-stream "" "F - test-copy-non-scalar: output should be empty") - 7190 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: 'x' is too large to fit in a register" "F - test-copy-non-scalar: error message") - 7191 # check that stop(1) was called - 7192 (check-ints-equal *(edx+4) 2 "F - test-copy-non-scalar: exit status") - 7193 # don't restore from ebp - 7194 81 0/subop/add %esp 8/imm32 - 7195 # . epilogue - 7196 5d/pop-to-ebp - 7197 c3/return - 7198 - 7199 test-copy-to-with-no-inout: - 7200 # . prologue - 7201 55/push-ebp - 7202 89/<- %ebp 4/r32/esp - 7203 # setup - 7204 (clear-stream _test-input-stream) - 7205 (clear-stream $_test-input-buffered-file->buffer) - 7206 (clear-stream _test-output-stream) - 7207 (clear-stream $_test-output-buffered-file->buffer) - 7208 (clear-stream _test-error-stream) - 7209 (clear-stream $_test-error-buffered-file->buffer) - 7210 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7211 68/push 0/imm32 - 7212 68/push 0/imm32 - 7213 89/<- %edx 4/r32/esp - 7214 (tailor-exit-descriptor %edx 0x10) - 7215 # - 7216 (write _test-input-stream "fn foo {\n") - 7217 (write _test-input-stream " copy-to\n") - 7218 (write _test-input-stream "}\n") - 7219 # convert - 7220 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7221 # registers except esp clobbered at this point - 7222 # restore ed + 6911 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6912 (flush _test-output-buffered-file) + 6913 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6919 # check output + 6920 (check-next-stream-line-equal _test-output-stream "f:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/0") + 6921 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/1") + 6922 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/2") + 6923 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/3") + 6924 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/4") + 6925 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/5") + 6926 # var a: t + 6927 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/6") + 6928 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/7") + 6929 # var b/eax: (addr t) + 6930 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/8") + 6931 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/9") + 6932 # foo a + 6933 (check-next-stream-line-equal _test-output-stream " (foo %eax)" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/10") + 6934 # + 6935 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/11") + 6936 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/12") + 6937 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/13") + 6938 (check-next-stream-line-equal _test-output-stream "$f:0x00000001:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/14") + 6939 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/15") + 6940 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/16") + 6941 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/17") + 6942 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/18") + 6943 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/19") + 6944 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/20") + 6945 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/21") + 6946 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/22") + 6947 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/23") + 6948 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/24") + 6949 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/25") + 6950 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0x00000008) 0x00000001/r32" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/26") + 6951 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/27") + 6952 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/28") + 6953 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/29") + 6954 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/30") + 6955 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/31") + 6956 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/32") + 6957 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-call-with-arg-of-user-defined-type-by-reference/33") + 6958 # . epilogue + 6959 89/<- %esp 5/r32/ebp + 6960 5d/pop-to-ebp + 6961 c3/return + 6962 + 6963 test-convert-get-on-local-variable: + 6964 # . prologue + 6965 55/push-ebp + 6966 89/<- %ebp 4/r32/esp + 6967 # setup + 6968 (clear-stream _test-input-stream) + 6969 (clear-stream $_test-input-buffered-file->buffer) + 6970 (clear-stream _test-output-stream) + 6971 (clear-stream $_test-output-buffered-file->buffer) + 6972 # + 6973 (write _test-input-stream "fn foo {\n") + 6974 (write _test-input-stream " var a: t\n") + 6975 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 6976 (write _test-input-stream "}\n") + 6977 (write _test-input-stream "type t {\n") + 6978 (write _test-input-stream " x: int\n") + 6979 (write _test-input-stream " y: int\n") + 6980 (write _test-input-stream "}\n") + 6981 # convert + 6982 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 6983 (flush _test-output-buffered-file) + 6984 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 6990 # check output + 6991 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-local-variable/0") + 6992 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-local-variable/1") + 6993 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-local-variable/2") + 6994 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-local-variable/3") + 6995 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-local-variable/4") + 6996 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-local-variable/5") + 6997 # var a + 6998 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/6") + 6999 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-get-on-local-variable/7") + 7000 # var c + 7001 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-local-variable/8") + 7002 # get + 7003 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0xfffffffc) 0x00000001/r32" "F - test-convert-get-on-local-variable/9") + 7004 # reclaim c + 7005 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-local-variable/10") + 7006 # reclaim a + 7007 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000008/imm32" "F - test-convert-get-on-local-variable/11") + 7008 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-local-variable/12") + 7009 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-local-variable/13") + 7010 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-local-variable/14") + 7011 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-local-variable/15") + 7012 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-local-variable/16") + 7013 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-local-variable/17") + 7014 # . epilogue + 7015 89/<- %esp 5/r32/ebp + 7016 5d/pop-to-ebp + 7017 c3/return + 7018 + 7019 test-convert-get-on-function-argument: + 7020 # . prologue + 7021 55/push-ebp + 7022 89/<- %ebp 4/r32/esp + 7023 # setup + 7024 (clear-stream _test-input-stream) + 7025 (clear-stream $_test-input-buffered-file->buffer) + 7026 (clear-stream _test-output-stream) + 7027 (clear-stream $_test-output-buffered-file->buffer) + 7028 # + 7029 (write _test-input-stream "fn foo a: t {\n") + 7030 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 7031 (write _test-input-stream "}\n") + 7032 (write _test-input-stream "type t {\n") + 7033 (write _test-input-stream " x: int\n") + 7034 (write _test-input-stream " y: int\n") + 7035 (write _test-input-stream "}\n") + 7036 # convert + 7037 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 7038 (flush _test-output-buffered-file) + 7039 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7045 # check output + 7046 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument/0") + 7047 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument/1") + 7048 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument/2") + 7049 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument/3") + 7050 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument/4") + 7051 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument/5") + 7052 # var c + 7053 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument/6") + 7054 # get + 7055 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument/7") + 7056 # reclaim c + 7057 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument/8") + 7058 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument/9") + 7059 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument/10") + 7060 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument/11") + 7061 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument/12") + 7062 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument/13") + 7063 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument/14") + 7064 # . epilogue + 7065 89/<- %esp 5/r32/ebp + 7066 5d/pop-to-ebp + 7067 c3/return + 7068 + 7069 test-convert-get-on-function-argument-with-known-type: + 7070 # . prologue + 7071 55/push-ebp + 7072 89/<- %ebp 4/r32/esp + 7073 # setup + 7074 (clear-stream _test-input-stream) + 7075 (clear-stream $_test-input-buffered-file->buffer) + 7076 (clear-stream _test-output-stream) + 7077 (clear-stream $_test-output-buffered-file->buffer) + 7078 # + 7079 (write _test-input-stream "type t {\n") + 7080 (write _test-input-stream " x: int\n") + 7081 (write _test-input-stream " y: int\n") + 7082 (write _test-input-stream "}\n") + 7083 (write _test-input-stream "fn foo a: t {\n") + 7084 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 7085 (write _test-input-stream "}\n") + 7086 # convert + 7087 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 7088 (flush _test-output-buffered-file) + 7089 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7095 # check output + 7096 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-get-on-function-argument-with-known-type/0") + 7097 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-get-on-function-argument-with-known-type/1") + 7098 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-get-on-function-argument-with-known-type/2") + 7099 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-get-on-function-argument-with-known-type/3") + 7100 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-get-on-function-argument-with-known-type/4") + 7101 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-get-on-function-argument-with-known-type/5") + 7102 # var c + 7103 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-get-on-function-argument-with-known-type/6") + 7104 # get + 7105 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(ebp+0x0000000c) 0x00000001/r32" "F - test-convert-get-on-function-argument-with-known-type/7") + 7106 # reclaim c + 7107 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-get-on-function-argument-with-known-type/8") + 7108 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-get-on-function-argument-with-known-type/9") + 7109 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-get-on-function-argument-with-known-type/10") + 7110 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-get-on-function-argument-with-known-type/11") + 7111 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-get-on-function-argument-with-known-type/12") + 7112 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-get-on-function-argument-with-known-type/13") + 7113 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-get-on-function-argument-with-known-type/14") + 7114 # . epilogue + 7115 89/<- %esp 5/r32/ebp + 7116 5d/pop-to-ebp + 7117 c3/return + 7118 + 7119 test-add-with-too-many-inouts: + 7120 # . prologue + 7121 55/push-ebp + 7122 89/<- %ebp 4/r32/esp + 7123 # setup + 7124 (clear-stream _test-input-stream) + 7125 (clear-stream $_test-input-buffered-file->buffer) + 7126 (clear-stream _test-output-stream) + 7127 (clear-stream $_test-output-buffered-file->buffer) + 7128 (clear-stream _test-error-stream) + 7129 (clear-stream $_test-error-buffered-file->buffer) + 7130 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7131 68/push 0/imm32 + 7132 68/push 0/imm32 + 7133 89/<- %edx 4/r32/esp + 7134 (tailor-exit-descriptor %edx 0x10) + 7135 # + 7136 (write _test-input-stream "fn foo {\n") + 7137 (write _test-input-stream " var a: int\n") + 7138 (write _test-input-stream " var b/ecx: int <- add a, 0\n") + 7139 (write _test-input-stream "}\n") + 7140 # convert + 7141 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7142 # registers except esp clobbered at this point + 7143 # restore ed + 7144 89/<- %edx 4/r32/esp + 7145 (flush _test-output-buffered-file) + 7146 (flush _test-error-buffered-file) + 7147 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7153 # check output + 7154 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts: output should be empty") + 7155 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts: error message") + 7156 # check that stop(1) was called + 7157 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts: exit status") + 7158 # don't restore from ebp + 7159 81 0/subop/add %esp 8/imm32 + 7160 # . epilogue + 7161 5d/pop-to-ebp + 7162 c3/return + 7163 + 7164 test-add-with-too-many-inouts-2: + 7165 # . prologue + 7166 55/push-ebp + 7167 89/<- %ebp 4/r32/esp + 7168 # setup + 7169 (clear-stream _test-input-stream) + 7170 (clear-stream $_test-input-buffered-file->buffer) + 7171 (clear-stream _test-output-stream) + 7172 (clear-stream $_test-output-buffered-file->buffer) + 7173 (clear-stream _test-error-stream) + 7174 (clear-stream $_test-error-buffered-file->buffer) + 7175 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7176 68/push 0/imm32 + 7177 68/push 0/imm32 + 7178 89/<- %edx 4/r32/esp + 7179 (tailor-exit-descriptor %edx 0x10) + 7180 # + 7181 (write _test-input-stream "fn foo {\n") + 7182 (write _test-input-stream " var a: int\n") + 7183 (write _test-input-stream " add-to a, 0, 1\n") + 7184 (write _test-input-stream "}\n") + 7185 # convert + 7186 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7187 # registers except esp clobbered at this point + 7188 # restore ed + 7189 89/<- %edx 4/r32/esp + 7190 (flush _test-output-buffered-file) + 7191 (flush _test-error-buffered-file) + 7192 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7198 # check output + 7199 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-inouts-2: output should be empty") + 7200 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add-to: too many inouts; most primitives support at most two arguments, across inouts and outputs" "F - test-add-with-too-many-inouts-2: error message") + 7201 # check that stop(1) was called + 7202 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-inouts-2: exit status") + 7203 # don't restore from ebp + 7204 81 0/subop/add %esp 8/imm32 + 7205 # . epilogue + 7206 5d/pop-to-ebp + 7207 c3/return + 7208 + 7209 test-add-with-too-many-outputs: + 7210 # . prologue + 7211 55/push-ebp + 7212 89/<- %ebp 4/r32/esp + 7213 # setup + 7214 (clear-stream _test-input-stream) + 7215 (clear-stream $_test-input-buffered-file->buffer) + 7216 (clear-stream _test-output-stream) + 7217 (clear-stream $_test-output-buffered-file->buffer) + 7218 (clear-stream _test-error-stream) + 7219 (clear-stream $_test-error-buffered-file->buffer) + 7220 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7221 68/push 0/imm32 + 7222 68/push 0/imm32 7223 89/<- %edx 4/r32/esp - 7224 (flush _test-output-buffered-file) - 7225 (flush _test-error-buffered-file) - 7226 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7232 # check output - 7233 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-no-inout: output should be empty") - 7234 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must have two inouts" "F - test-copy-to-with-no-inout: error message") - 7235 # check that stop(1) was called - 7236 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-no-inout: exit status") - 7237 # don't restore from ebp - 7238 81 0/subop/add %esp 8/imm32 - 7239 # . epilogue - 7240 5d/pop-to-ebp - 7241 c3/return - 7242 - 7243 test-copy-to-with-no-input: - 7244 # . prologue - 7245 55/push-ebp - 7246 89/<- %ebp 4/r32/esp - 7247 # setup - 7248 (clear-stream _test-input-stream) - 7249 (clear-stream $_test-input-buffered-file->buffer) - 7250 (clear-stream _test-output-stream) - 7251 (clear-stream $_test-output-buffered-file->buffer) - 7252 (clear-stream _test-error-stream) - 7253 (clear-stream $_test-error-buffered-file->buffer) - 7254 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7255 68/push 0/imm32 - 7256 68/push 0/imm32 - 7257 89/<- %edx 4/r32/esp - 7258 (tailor-exit-descriptor %edx 0x10) - 7259 # - 7260 (write _test-input-stream "fn foo {\n") - 7261 (write _test-input-stream " var x: boolean\n") - 7262 (write _test-input-stream " copy-to x\n") - 7263 (write _test-input-stream "}\n") - 7264 # convert - 7265 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7266 # registers except esp clobbered at this point - 7267 # restore ed - 7268 89/<- %edx 4/r32/esp - 7269 (flush _test-output-buffered-file) - 7270 (flush _test-error-buffered-file) - 7271 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7277 # check output - 7278 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-no-input: output should be empty") - 7279 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must have two inouts" "F - test-copy-to-with-no-input: error message") - 7280 # check that stop(1) was called - 7281 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-no-input: exit status") - 7282 # don't restore from ebp - 7283 81 0/subop/add %esp 8/imm32 - 7284 # . epilogue - 7285 5d/pop-to-ebp - 7286 c3/return - 7287 - 7288 test-copy-to-with-no-register: - 7289 # . prologue - 7290 55/push-ebp - 7291 89/<- %ebp 4/r32/esp - 7292 # setup - 7293 (clear-stream _test-input-stream) - 7294 (clear-stream $_test-input-buffered-file->buffer) - 7295 (clear-stream _test-output-stream) - 7296 (clear-stream $_test-output-buffered-file->buffer) - 7297 (clear-stream _test-error-stream) - 7298 (clear-stream $_test-error-buffered-file->buffer) - 7299 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7300 68/push 0/imm32 - 7301 68/push 0/imm32 - 7302 89/<- %edx 4/r32/esp - 7303 (tailor-exit-descriptor %edx 0x10) - 7304 # - 7305 (write _test-input-stream "fn foo {\n") - 7306 (write _test-input-stream " var x: boolean\n") - 7307 (write _test-input-stream " copy-to x, x\n") - 7308 (write _test-input-stream "}\n") - 7309 # convert - 7310 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7311 # registers except esp clobbered at this point - 7312 # restore ed - 7313 89/<- %edx 4/r32/esp - 7314 (flush _test-output-buffered-file) - 7315 (flush _test-error-buffered-file) - 7316 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7322 # check output - 7323 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-no-register: output should be empty") - 7324 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: source (second inout) is in memory" "F - test-copy-to-with-no-register: error message") - 7325 # check that stop(1) was called - 7326 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-no-register: exit status") - 7327 # don't restore from ebp - 7328 81 0/subop/add %esp 8/imm32 - 7329 # . epilogue - 7330 5d/pop-to-ebp - 7331 c3/return - 7332 - 7333 test-copy-to-with-too-many-inouts: - 7334 # . prologue - 7335 55/push-ebp - 7336 89/<- %ebp 4/r32/esp - 7337 # setup - 7338 (clear-stream _test-input-stream) - 7339 (clear-stream $_test-input-buffered-file->buffer) - 7340 (clear-stream _test-output-stream) - 7341 (clear-stream $_test-output-buffered-file->buffer) - 7342 (clear-stream _test-error-stream) - 7343 (clear-stream $_test-error-buffered-file->buffer) - 7344 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7345 68/push 0/imm32 - 7346 68/push 0/imm32 - 7347 89/<- %edx 4/r32/esp - 7348 (tailor-exit-descriptor %edx 0x10) - 7349 # - 7350 (write _test-input-stream "fn foo {\n") - 7351 (write _test-input-stream " var x: boolean\n") - 7352 (write _test-input-stream " copy-to x, 0, 0\n") - 7353 (write _test-input-stream "}\n") - 7354 # convert - 7355 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7356 # registers except esp clobbered at this point - 7357 # restore ed - 7358 89/<- %edx 4/r32/esp - 7359 (flush _test-output-buffered-file) - 7360 (flush _test-error-buffered-file) - 7361 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7367 # check output - 7368 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-too-many-inouts: output should be empty") - 7369 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must have two inouts" "F - test-copy-to-with-too-many-inouts: error message") - 7370 # check that stop(1) was called - 7371 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-too-many-inouts: exit status") - 7372 # don't restore from ebp - 7373 81 0/subop/add %esp 8/imm32 - 7374 # . epilogue - 7375 5d/pop-to-ebp - 7376 c3/return - 7377 - 7378 test-copy-to-with-output: - 7379 # . prologue - 7380 55/push-ebp - 7381 89/<- %ebp 4/r32/esp - 7382 # setup - 7383 (clear-stream _test-input-stream) - 7384 (clear-stream $_test-input-buffered-file->buffer) - 7385 (clear-stream _test-output-stream) - 7386 (clear-stream $_test-output-buffered-file->buffer) - 7387 (clear-stream _test-error-stream) - 7388 (clear-stream $_test-error-buffered-file->buffer) - 7389 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7390 68/push 0/imm32 - 7391 68/push 0/imm32 + 7224 (tailor-exit-descriptor %edx 0x10) + 7225 # + 7226 (write _test-input-stream "fn foo {\n") + 7227 (write _test-input-stream " var a/eax: int <- copy 0\n") + 7228 (write _test-input-stream " var b/ebx: int <- copy 0\n") + 7229 (write _test-input-stream " var c/ecx: int <- copy 0\n") + 7230 (write _test-input-stream " c, b <- add a\n") + 7231 (write _test-input-stream "}\n") + 7232 # convert + 7233 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7234 # registers except esp clobbered at this point + 7235 # restore ed + 7236 89/<- %edx 4/r32/esp + 7237 (flush _test-output-buffered-file) + 7238 (flush _test-error-buffered-file) + 7239 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7245 # check output + 7246 (check-stream-equal _test-output-stream "" "F - test-add-with-too-many-outputs: output should be empty") + 7247 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: too many outputs; most primitives support at most one output" "F - test-add-with-too-many-outputs: error message") + 7248 # check that stop(1) was called + 7249 (check-ints-equal *(edx+4) 2 "F - test-add-with-too-many-outputs: exit status") + 7250 # don't restore from ebp + 7251 81 0/subop/add %esp 8/imm32 + 7252 # . epilogue + 7253 5d/pop-to-ebp + 7254 c3/return + 7255 + 7256 test-add-with-non-number: + 7257 # . prologue + 7258 55/push-ebp + 7259 89/<- %ebp 4/r32/esp + 7260 # setup + 7261 (clear-stream _test-input-stream) + 7262 (clear-stream $_test-input-buffered-file->buffer) + 7263 (clear-stream _test-output-stream) + 7264 (clear-stream $_test-output-buffered-file->buffer) + 7265 (clear-stream _test-error-stream) + 7266 (clear-stream $_test-error-buffered-file->buffer) + 7267 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7268 68/push 0/imm32 + 7269 68/push 0/imm32 + 7270 89/<- %edx 4/r32/esp + 7271 (tailor-exit-descriptor %edx 0x10) + 7272 # + 7273 (write _test-input-stream "fn foo {\n") + 7274 (write _test-input-stream " var a: int\n") + 7275 (write _test-input-stream " var b/ecx: (addr int) <- add a\n") + 7276 (write _test-input-stream "}\n") + 7277 # convert + 7278 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7279 # registers except esp clobbered at this point + 7280 # restore ed + 7281 89/<- %edx 4/r32/esp + 7282 (flush _test-output-buffered-file) + 7283 (flush _test-error-buffered-file) + 7284 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7290 # check output + 7291 (check-stream-equal _test-output-stream "" "F - test-add-with-non-number: output should be empty") + 7292 (check-next-stream-line-equal _test-error-stream "fn foo: stmt add: 'b' must be a non-addr non-offset scalar" "F - test-add-with-non-number: error message") + 7293 # check that stop(1) was called + 7294 (check-ints-equal *(edx+4) 2 "F - test-add-with-non-number: exit status") + 7295 # don't restore from ebp + 7296 81 0/subop/add %esp 8/imm32 + 7297 # . epilogue + 7298 5d/pop-to-ebp + 7299 c3/return + 7300 + 7301 test-add-with-addr-dereferenced: + 7302 # . prologue + 7303 55/push-ebp + 7304 89/<- %ebp 4/r32/esp + 7305 # setup + 7306 (clear-stream _test-input-stream) + 7307 (clear-stream $_test-input-buffered-file->buffer) + 7308 (clear-stream _test-output-stream) + 7309 (clear-stream $_test-output-buffered-file->buffer) + 7310 # + 7311 (write _test-input-stream "fn foo {\n") + 7312 (write _test-input-stream " var a/eax: (addr int) <- copy 0\n") + 7313 (write _test-input-stream " add-to *a, 1\n") + 7314 (write _test-input-stream "}\n") + 7315 # convert + 7316 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 7317 (flush _test-output-buffered-file) + 7318 # no error + 7319 # . epilogue + 7320 89/<- %esp 5/r32/ebp + 7321 5d/pop-to-ebp + 7322 c3/return + 7323 + 7324 test-copy-with-no-inout: + 7325 # . prologue + 7326 55/push-ebp + 7327 89/<- %ebp 4/r32/esp + 7328 # setup + 7329 (clear-stream _test-input-stream) + 7330 (clear-stream $_test-input-buffered-file->buffer) + 7331 (clear-stream _test-output-stream) + 7332 (clear-stream $_test-output-buffered-file->buffer) + 7333 (clear-stream _test-error-stream) + 7334 (clear-stream $_test-error-buffered-file->buffer) + 7335 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7336 68/push 0/imm32 + 7337 68/push 0/imm32 + 7338 89/<- %edx 4/r32/esp + 7339 (tailor-exit-descriptor %edx 0x10) + 7340 # + 7341 (write _test-input-stream "fn foo {\n") + 7342 (write _test-input-stream " var x/eax: boolean <- copy\n") + 7343 (write _test-input-stream "}\n") + 7344 # convert + 7345 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7346 # registers except esp clobbered at this point + 7347 # restore ed + 7348 89/<- %edx 4/r32/esp + 7349 (flush _test-output-buffered-file) + 7350 (flush _test-error-buffered-file) + 7351 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7357 # check output + 7358 (check-stream-equal _test-output-stream "" "F - test-copy-with-no-inout: output should be empty") + 7359 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' expects an inout" "F - test-copy-with-no-inout: error message") + 7360 # check that stop(1) was called + 7361 (check-ints-equal *(edx+4) 2 "F - test-copy-with-no-inout: exit status") + 7362 # don't restore from ebp + 7363 81 0/subop/add %esp 8/imm32 + 7364 # . epilogue + 7365 5d/pop-to-ebp + 7366 c3/return + 7367 + 7368 test-copy-with-multiple-inouts: + 7369 # . prologue + 7370 55/push-ebp + 7371 89/<- %ebp 4/r32/esp + 7372 # setup + 7373 (clear-stream _test-input-stream) + 7374 (clear-stream $_test-input-buffered-file->buffer) + 7375 (clear-stream _test-output-stream) + 7376 (clear-stream $_test-output-buffered-file->buffer) + 7377 (clear-stream _test-error-stream) + 7378 (clear-stream $_test-error-buffered-file->buffer) + 7379 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7380 68/push 0/imm32 + 7381 68/push 0/imm32 + 7382 89/<- %edx 4/r32/esp + 7383 (tailor-exit-descriptor %edx 0x10) + 7384 # + 7385 (write _test-input-stream "fn foo {\n") + 7386 (write _test-input-stream " var x/eax: boolean <- copy 0, 0\n") + 7387 (write _test-input-stream "}\n") + 7388 # convert + 7389 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7390 # registers except esp clobbered at this point + 7391 # restore ed 7392 89/<- %edx 4/r32/esp - 7393 (tailor-exit-descriptor %edx 0x10) - 7394 # - 7395 (write _test-input-stream "fn foo {\n") - 7396 (write _test-input-stream " var x/eax: boolean <- copy 0\n") - 7397 (write _test-input-stream " var y/ecx: boolean <- copy 0\n") - 7398 (write _test-input-stream " x <- copy-to y, 0\n") - 7399 (write _test-input-stream "}\n") - 7400 # convert - 7401 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7402 # registers except esp clobbered at this point - 7403 # restore ed - 7404 89/<- %edx 4/r32/esp - 7405 (flush _test-output-buffered-file) - 7406 (flush _test-error-buffered-file) - 7407 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7413 # check output - 7414 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-output: output should be empty") - 7415 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must not have any outputs" "F - test-copy-to-with-output: error message") - 7416 # check that stop(1) was called - 7417 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-output: exit status") - 7418 # don't restore from ebp - 7419 81 0/subop/add %esp 8/imm32 - 7420 # . epilogue - 7421 5d/pop-to-ebp - 7422 c3/return - 7423 - 7424 test-copy-to-invalid-value-to-address: - 7425 # . prologue - 7426 55/push-ebp - 7427 89/<- %ebp 4/r32/esp - 7428 # setup - 7429 (clear-stream _test-input-stream) - 7430 (clear-stream $_test-input-buffered-file->buffer) - 7431 (clear-stream _test-output-stream) - 7432 (clear-stream $_test-output-buffered-file->buffer) - 7433 (clear-stream _test-error-stream) - 7434 (clear-stream $_test-error-buffered-file->buffer) - 7435 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7436 68/push 0/imm32 - 7437 68/push 0/imm32 - 7438 89/<- %edx 4/r32/esp - 7439 (tailor-exit-descriptor %edx 0x10) - 7440 # - 7441 (write _test-input-stream "fn foo {\n") - 7442 (write _test-input-stream " var x/eax: int <- copy 0\n") - 7443 (write _test-input-stream " var y: (addr int)\n") - 7444 (write _test-input-stream " copy-to y, x\n") - 7445 (write _test-input-stream "}\n") - 7446 # convert - 7447 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7448 # registers except esp clobbered at this point - 7449 # restore ed - 7450 89/<- %edx 4/r32/esp - 7451 (flush _test-output-buffered-file) - 7452 (flush _test-error-buffered-file) - 7453 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7459 # check output - 7460 (check-stream-equal _test-output-stream "" "F - test-copy-to-invalid-value-to-address: output should be empty") - 7461 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: 'y' must be a non-addr non-offset scalar" "F - test-copy-to-invalid-value-to-address: error message") - 7462 # check that stop(1) was called - 7463 (check-ints-equal *(edx+4) 2 "F - test-copy-to-invalid-value-to-address: exit status") - 7464 # don't restore from ebp - 7465 81 0/subop/add %esp 8/imm32 - 7466 # . epilogue - 7467 5d/pop-to-ebp - 7468 c3/return - 7469 - 7470 test-copy-to-deref-address: - 7471 # . prologue - 7472 55/push-ebp - 7473 89/<- %ebp 4/r32/esp - 7474 # setup - 7475 (clear-stream _test-input-stream) - 7476 (clear-stream $_test-input-buffered-file->buffer) - 7477 (clear-stream _test-output-stream) - 7478 (clear-stream $_test-output-buffered-file->buffer) - 7479 # - 7480 (write _test-input-stream "fn foo {\n") - 7481 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") - 7482 (write _test-input-stream " var y/ecx: (addr addr int) <- copy 0\n") - 7483 (write _test-input-stream " copy-to *y, x\n") - 7484 (write _test-input-stream "}\n") - 7485 # convert - 7486 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 7487 (flush _test-output-buffered-file) - 7488 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7494 # not bothering checking output - 7495 (check-next-stream-line-equal _test-error-stream "" "F - test-copy-to-deref-address: error message") - 7496 # . epilogue - 7497 5d/pop-to-ebp - 7498 c3/return - 7499 - 7500 test-copy-to-non-scalar: - 7501 # . prologue - 7502 55/push-ebp - 7503 89/<- %ebp 4/r32/esp - 7504 # setup - 7505 (clear-stream _test-input-stream) - 7506 (clear-stream $_test-input-buffered-file->buffer) - 7507 (clear-stream _test-output-stream) - 7508 (clear-stream $_test-output-buffered-file->buffer) - 7509 (clear-stream _test-error-stream) - 7510 (clear-stream $_test-error-buffered-file->buffer) - 7511 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7512 68/push 0/imm32 - 7513 68/push 0/imm32 - 7514 89/<- %edx 4/r32/esp - 7515 (tailor-exit-descriptor %edx 0x10) - 7516 # - 7517 (write _test-input-stream "fn foo {\n") - 7518 (write _test-input-stream " var x: (handle int)\n") - 7519 (write _test-input-stream " var y: int\n") - 7520 (write _test-input-stream " copy-to y, x\n") - 7521 (write _test-input-stream "}\n") - 7522 # convert - 7523 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7524 # registers except esp clobbered at this point - 7525 # restore ed - 7526 89/<- %edx 4/r32/esp - 7527 (flush _test-output-buffered-file) - 7528 (flush _test-error-buffered-file) - 7529 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7535 # check output - 7536 (check-stream-equal _test-output-stream "" "F - test-copy-to-non-scalar: output should be empty") - 7537 #? (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: 'x' is too large to copy" "F - test-copy-to-non-scalar: error message") - 7538 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: source (second inout) is in memory" "F - test-copy-to-non-scalar: error message") + 7393 (flush _test-output-buffered-file) + 7394 (flush _test-error-buffered-file) + 7395 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7401 # check output + 7402 (check-stream-equal _test-output-stream "" "F - test-copy-with-multiple-inouts: output should be empty") + 7403 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' must have just one inout" "F - test-copy-with-multiple-inouts: error message") + 7404 # check that stop(1) was called + 7405 (check-ints-equal *(edx+4) 2 "F - test-copy-with-multiple-inouts: exit status") + 7406 # don't restore from ebp + 7407 81 0/subop/add %esp 8/imm32 + 7408 # . epilogue + 7409 5d/pop-to-ebp + 7410 c3/return + 7411 + 7412 test-copy-with-no-output: + 7413 # . prologue + 7414 55/push-ebp + 7415 89/<- %ebp 4/r32/esp + 7416 # setup + 7417 (clear-stream _test-input-stream) + 7418 (clear-stream $_test-input-buffered-file->buffer) + 7419 (clear-stream _test-output-stream) + 7420 (clear-stream $_test-output-buffered-file->buffer) + 7421 (clear-stream _test-error-stream) + 7422 (clear-stream $_test-error-buffered-file->buffer) + 7423 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7424 68/push 0/imm32 + 7425 68/push 0/imm32 + 7426 89/<- %edx 4/r32/esp + 7427 (tailor-exit-descriptor %edx 0x10) + 7428 # + 7429 (write _test-input-stream "fn foo {\n") + 7430 (write _test-input-stream " copy 0\n") + 7431 (write _test-input-stream "}\n") + 7432 # convert + 7433 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7434 # registers except esp clobbered at this point + 7435 # restore ed + 7436 89/<- %edx 4/r32/esp + 7437 (flush _test-output-buffered-file) + 7438 (flush _test-error-buffered-file) + 7439 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7445 # check output + 7446 (check-stream-equal _test-output-stream "" "F - test-copy-with-no-output: output should be empty") + 7447 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' expects an output" "F - test-copy-with-no-output: error message") + 7448 # check that stop(1) was called + 7449 (check-ints-equal *(edx+4) 2 "F - test-copy-with-no-output: exit status") + 7450 # don't restore from ebp + 7451 81 0/subop/add %esp 8/imm32 + 7452 # . epilogue + 7453 5d/pop-to-ebp + 7454 c3/return + 7455 + 7456 test-copy-with-multiple-outputs: + 7457 # . prologue + 7458 55/push-ebp + 7459 89/<- %ebp 4/r32/esp + 7460 # setup + 7461 (clear-stream _test-input-stream) + 7462 (clear-stream $_test-input-buffered-file->buffer) + 7463 (clear-stream _test-output-stream) + 7464 (clear-stream $_test-output-buffered-file->buffer) + 7465 (clear-stream _test-error-stream) + 7466 (clear-stream $_test-error-buffered-file->buffer) + 7467 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7468 68/push 0/imm32 + 7469 68/push 0/imm32 + 7470 89/<- %edx 4/r32/esp + 7471 (tailor-exit-descriptor %edx 0x10) + 7472 # + 7473 (write _test-input-stream "fn foo {\n") + 7474 (write _test-input-stream " var x/eax: boolean <- copy 0\n") + 7475 (write _test-input-stream " var y/ecx: boolean <- copy 0\n") + 7476 (write _test-input-stream " x, y <- copy 0\n") + 7477 (write _test-input-stream "}\n") + 7478 # convert + 7479 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7480 # registers except esp clobbered at this point + 7481 # restore ed + 7482 89/<- %edx 4/r32/esp + 7483 (flush _test-output-buffered-file) + 7484 (flush _test-error-buffered-file) + 7485 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7491 # check output + 7492 (check-stream-equal _test-output-stream "" "F - test-copy-with-multiple-outputs: output should be empty") + 7493 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy' must have just one output" "F - test-copy-with-multiple-outputs: error message") + 7494 # check that stop(1) was called + 7495 (check-ints-equal *(edx+4) 2 "F - test-copy-with-multiple-outputs: exit status") + 7496 # don't restore from ebp + 7497 81 0/subop/add %esp 8/imm32 + 7498 # . epilogue + 7499 5d/pop-to-ebp + 7500 c3/return + 7501 + 7502 test-copy-invalid-value-to-address: + 7503 # . prologue + 7504 55/push-ebp + 7505 89/<- %ebp 4/r32/esp + 7506 # setup + 7507 (clear-stream _test-input-stream) + 7508 (clear-stream $_test-input-buffered-file->buffer) + 7509 (clear-stream _test-output-stream) + 7510 (clear-stream $_test-output-buffered-file->buffer) + 7511 (clear-stream _test-error-stream) + 7512 (clear-stream $_test-error-buffered-file->buffer) + 7513 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7514 68/push 0/imm32 + 7515 68/push 0/imm32 + 7516 89/<- %edx 4/r32/esp + 7517 (tailor-exit-descriptor %edx 0x10) + 7518 # + 7519 (write _test-input-stream "fn foo {\n") + 7520 (write _test-input-stream " var x/eax: int <- copy 0\n") + 7521 (write _test-input-stream " var y/ecx: (addr int) <- copy x\n") + 7522 (write _test-input-stream "}\n") + 7523 # convert + 7524 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7525 # registers except esp clobbered at this point + 7526 # restore ed + 7527 89/<- %edx 4/r32/esp + 7528 (flush _test-output-buffered-file) + 7529 (flush _test-error-buffered-file) + 7530 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7536 # check output + 7537 (check-stream-equal _test-output-stream "" "F - test-copy-invalid-value-to-address: output should be empty") + 7538 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: 'y' must be a non-addr non-offset scalar" "F - test-copy-invalid-value-to-address: error message") 7539 # check that stop(1) was called - 7540 (check-ints-equal *(edx+4) 2 "F - test-copy-to-non-scalar: exit status") + 7540 (check-ints-equal *(edx+4) 2 "F - test-copy-invalid-value-to-address: exit status") 7541 # don't restore from ebp 7542 81 0/subop/add %esp 8/imm32 7543 # . epilogue 7544 5d/pop-to-ebp 7545 c3/return 7546 - 7547 test-compare-with-no-inout: + 7547 test-copy-null-value-to-addr: 7548 # . prologue 7549 55/push-ebp 7550 89/<- %ebp 4/r32/esp @@ -6900,4670 +6910,4660 @@ if ('onhashchange' in window) { 7553 (clear-stream $_test-input-buffered-file->buffer) 7554 (clear-stream _test-output-stream) 7555 (clear-stream $_test-output-buffered-file->buffer) - 7556 (clear-stream _test-error-stream) - 7557 (clear-stream $_test-error-buffered-file->buffer) - 7558 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7559 68/push 0/imm32 - 7560 68/push 0/imm32 - 7561 89/<- %edx 4/r32/esp - 7562 (tailor-exit-descriptor %edx 0x10) - 7563 # - 7564 (write _test-input-stream "fn foo {\n") - 7565 (write _test-input-stream " var x: boolean\n") - 7566 (write _test-input-stream " compare\n") - 7567 (write _test-input-stream "}\n") - 7568 # convert - 7569 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7570 # registers except esp clobbered at this point - 7571 # restore ed - 7572 89/<- %edx 4/r32/esp - 7573 (flush _test-output-buffered-file) - 7574 (flush _test-error-buffered-file) - 7575 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7581 # check output - 7582 (check-stream-equal _test-output-stream "" "F - test-compare-with-no-inout: output should be empty") - 7583 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must have two inouts" "F - test-compare-with-no-inout: error message") - 7584 # check that stop(1) was called - 7585 (check-ints-equal *(edx+4) 2 "F - test-compare-with-no-inout: exit status") - 7586 # don't restore from ebp - 7587 81 0/subop/add %esp 8/imm32 - 7588 # . epilogue - 7589 5d/pop-to-ebp - 7590 c3/return - 7591 - 7592 test-compare-with-no-input: - 7593 # . prologue - 7594 55/push-ebp - 7595 89/<- %ebp 4/r32/esp - 7596 # setup - 7597 (clear-stream _test-input-stream) - 7598 (clear-stream $_test-input-buffered-file->buffer) - 7599 (clear-stream _test-output-stream) - 7600 (clear-stream $_test-output-buffered-file->buffer) - 7601 (clear-stream _test-error-stream) - 7602 (clear-stream $_test-error-buffered-file->buffer) - 7603 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7604 68/push 0/imm32 - 7605 68/push 0/imm32 - 7606 89/<- %edx 4/r32/esp - 7607 (tailor-exit-descriptor %edx 0x10) - 7608 # - 7609 (write _test-input-stream "fn foo {\n") - 7610 (write _test-input-stream " var x: boolean\n") - 7611 (write _test-input-stream " compare x\n") - 7612 (write _test-input-stream "}\n") - 7613 # convert - 7614 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7615 # registers except esp clobbered at this point - 7616 # restore ed - 7617 89/<- %edx 4/r32/esp - 7618 (flush _test-output-buffered-file) - 7619 (flush _test-error-buffered-file) - 7620 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7626 # check output - 7627 (check-stream-equal _test-output-stream "" "F - test-compare-with-no-input: output should be empty") - 7628 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must have two inouts" "F - test-compare-with-no-input: error message") - 7629 # check that stop(1) was called - 7630 (check-ints-equal *(edx+4) 2 "F - test-compare-with-no-input: exit status") - 7631 # don't restore from ebp - 7632 81 0/subop/add %esp 8/imm32 - 7633 # . epilogue - 7634 5d/pop-to-ebp - 7635 c3/return - 7636 - 7637 test-compare-with-too-many-inouts: - 7638 # . prologue - 7639 55/push-ebp - 7640 89/<- %ebp 4/r32/esp - 7641 # setup - 7642 (clear-stream _test-input-stream) - 7643 (clear-stream $_test-input-buffered-file->buffer) - 7644 (clear-stream _test-output-stream) - 7645 (clear-stream $_test-output-buffered-file->buffer) - 7646 (clear-stream _test-error-stream) - 7647 (clear-stream $_test-error-buffered-file->buffer) - 7648 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7649 68/push 0/imm32 - 7650 68/push 0/imm32 - 7651 89/<- %edx 4/r32/esp - 7652 (tailor-exit-descriptor %edx 0x10) - 7653 # - 7654 (write _test-input-stream "fn foo {\n") - 7655 (write _test-input-stream " var x: boolean\n") - 7656 (write _test-input-stream " compare x, 0, 0\n") - 7657 (write _test-input-stream "}\n") - 7658 # convert - 7659 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7660 # registers except esp clobbered at this point - 7661 # restore ed - 7662 89/<- %edx 4/r32/esp - 7663 (flush _test-output-buffered-file) - 7664 (flush _test-error-buffered-file) + 7556 # + 7557 (write _test-input-stream "fn foo {\n") + 7558 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") + 7559 (write _test-input-stream "}\n") + 7560 # convert + 7561 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 7562 (flush _test-output-buffered-file) + 7563 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7569 # no errors + 7570 # . epilogue + 7571 89/<- %esp 5/r32/ebp + 7572 5d/pop-to-ebp + 7573 c3/return + 7574 + 7575 test-copy-invalid-value-to-offset: + 7576 # . prologue + 7577 55/push-ebp + 7578 89/<- %ebp 4/r32/esp + 7579 # setup + 7580 (clear-stream _test-input-stream) + 7581 (clear-stream $_test-input-buffered-file->buffer) + 7582 (clear-stream _test-output-stream) + 7583 (clear-stream $_test-output-buffered-file->buffer) + 7584 (clear-stream _test-error-stream) + 7585 (clear-stream $_test-error-buffered-file->buffer) + 7586 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7587 68/push 0/imm32 + 7588 68/push 0/imm32 + 7589 89/<- %edx 4/r32/esp + 7590 (tailor-exit-descriptor %edx 0x10) + 7591 # + 7592 (write _test-input-stream "fn foo {\n") + 7593 (write _test-input-stream " var x/eax: int <- copy 0\n") + 7594 (write _test-input-stream " var y/ecx: (offset int) <- copy x\n") + 7595 (write _test-input-stream "}\n") + 7596 # convert + 7597 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7598 # registers except esp clobbered at this point + 7599 # restore ed + 7600 89/<- %edx 4/r32/esp + 7601 (flush _test-output-buffered-file) + 7602 (flush _test-error-buffered-file) + 7603 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7609 # check output + 7610 (check-stream-equal _test-output-stream "" "F - test-copy-invalid-value-to-address: output should be empty") + 7611 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: 'y' must be a non-addr non-offset scalar" "F - test-copy-invalid-value-to-address: error message") + 7612 # check that stop(1) was called + 7613 (check-ints-equal *(edx+4) 2 "F - test-copy-invalid-value-to-offset: exit status") + 7614 # don't restore from ebp + 7615 81 0/subop/add %esp 8/imm32 + 7616 # . epilogue + 7617 5d/pop-to-ebp + 7618 c3/return + 7619 + 7620 test-copy-null-value-to-offset: + 7621 # . prologue + 7622 55/push-ebp + 7623 89/<- %ebp 4/r32/esp + 7624 # setup + 7625 (clear-stream _test-input-stream) + 7626 (clear-stream $_test-input-buffered-file->buffer) + 7627 (clear-stream _test-output-stream) + 7628 (clear-stream $_test-output-buffered-file->buffer) + 7629 # + 7630 (write _test-input-stream "fn foo {\n") + 7631 (write _test-input-stream " var y/ecx: (offset int) <- copy 0\n") + 7632 (write _test-input-stream "}\n") + 7633 # convert + 7634 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 7635 (flush _test-output-buffered-file) + 7636 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7642 # no errors + 7643 # . epilogue + 7644 89/<- %esp 5/r32/ebp + 7645 5d/pop-to-ebp + 7646 c3/return + 7647 + 7648 test-copy-deref-address: + 7649 # . prologue + 7650 55/push-ebp + 7651 89/<- %ebp 4/r32/esp + 7652 # setup + 7653 (clear-stream _test-input-stream) + 7654 (clear-stream $_test-input-buffered-file->buffer) + 7655 (clear-stream _test-output-stream) + 7656 (clear-stream $_test-output-buffered-file->buffer) + 7657 # + 7658 (write _test-input-stream "fn foo {\n") + 7659 (write _test-input-stream " var x/eax: (addr addr int) <- copy 0\n") + 7660 (write _test-input-stream " var y/ecx: (addr int) <- copy *x\n") + 7661 (write _test-input-stream "}\n") + 7662 # convert + 7663 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 7664 (flush _test-output-buffered-file) 7665 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7671 # check output - 7672 (check-stream-equal _test-output-stream "" "F - test-compare-with-too-many-inouts: output should be empty") - 7673 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must have two inouts" "F - test-compare-with-too-many-inouts: error message") - 7674 # check that stop(1) was called - 7675 (check-ints-equal *(edx+4) 2 "F - test-compare-with-too-many-inouts: exit status") - 7676 # don't restore from ebp - 7677 81 0/subop/add %esp 8/imm32 - 7678 # . epilogue - 7679 5d/pop-to-ebp - 7680 c3/return - 7681 - 7682 test-compare-with-output: - 7683 # . prologue - 7684 55/push-ebp - 7685 89/<- %ebp 4/r32/esp - 7686 # setup - 7687 (clear-stream _test-input-stream) - 7688 (clear-stream $_test-input-buffered-file->buffer) - 7689 (clear-stream _test-output-stream) - 7690 (clear-stream $_test-output-buffered-file->buffer) - 7691 (clear-stream _test-error-stream) - 7692 (clear-stream $_test-error-buffered-file->buffer) - 7693 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7694 68/push 0/imm32 - 7695 68/push 0/imm32 - 7696 89/<- %edx 4/r32/esp - 7697 (tailor-exit-descriptor %edx 0x10) - 7698 # - 7699 (write _test-input-stream "fn foo {\n") - 7700 (write _test-input-stream " var x/eax: boolean <- copy 0\n") - 7701 (write _test-input-stream " var y/ecx: boolean <- copy 0\n") - 7702 (write _test-input-stream " x <- compare y, 0\n") - 7703 (write _test-input-stream "}\n") - 7704 # convert - 7705 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7706 # registers except esp clobbered at this point - 7707 # restore ed - 7708 89/<- %edx 4/r32/esp - 7709 (flush _test-output-buffered-file) - 7710 (flush _test-error-buffered-file) - 7711 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7717 # check output - 7718 (check-stream-equal _test-output-stream "" "F - test-compare-with-output: output should be empty") - 7719 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must not have any outputs" "F - test-compare-with-output: error message") - 7720 # check that stop(1) was called - 7721 (check-ints-equal *(edx+4) 2 "F - test-compare-with-output: exit status") - 7722 # don't restore from ebp - 7723 81 0/subop/add %esp 8/imm32 - 7724 # . epilogue - 7725 5d/pop-to-ebp - 7726 c3/return - 7727 - 7728 test-compare-invalid-value-to-address: - 7729 # . prologue - 7730 55/push-ebp - 7731 89/<- %ebp 4/r32/esp - 7732 # setup - 7733 (clear-stream _test-input-stream) - 7734 (clear-stream $_test-input-buffered-file->buffer) - 7735 (clear-stream _test-output-stream) - 7736 (clear-stream $_test-output-buffered-file->buffer) - 7737 (clear-stream _test-error-stream) - 7738 (clear-stream $_test-error-buffered-file->buffer) - 7739 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7740 68/push 0/imm32 - 7741 68/push 0/imm32 - 7742 89/<- %edx 4/r32/esp - 7743 (tailor-exit-descriptor %edx 0x10) - 7744 # - 7745 (write _test-input-stream "fn foo {\n") - 7746 (write _test-input-stream " var x/eax: int <- copy 0\n") - 7747 (write _test-input-stream " var y: (addr int)\n") - 7748 (write _test-input-stream " compare y, x\n") - 7749 (write _test-input-stream "}\n") - 7750 # convert - 7751 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7752 # registers except esp clobbered at this point - 7753 # restore ed - 7754 89/<- %edx 4/r32/esp - 7755 (flush _test-output-buffered-file) - 7756 (flush _test-error-buffered-file) - 7757 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7763 # check output - 7764 (check-stream-equal _test-output-stream "" "F - test-compare-invalid-value-to-address: output should be empty") - 7765 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: 'y' must be a non-addr non-offset scalar" "F - test-compare-invalid-value-to-address: error message") - 7766 # check that stop(1) was called - 7767 (check-ints-equal *(edx+4) 2 "F - test-compare-invalid-value-to-address: exit status") - 7768 # don't restore from ebp - 7769 81 0/subop/add %esp 8/imm32 - 7770 # . epilogue - 7771 5d/pop-to-ebp - 7772 c3/return - 7773 - 7774 test-compare-address: - 7775 # . prologue - 7776 55/push-ebp - 7777 89/<- %ebp 4/r32/esp - 7778 # setup - 7779 (clear-stream _test-input-stream) - 7780 (clear-stream $_test-input-buffered-file->buffer) - 7781 (clear-stream _test-output-stream) - 7782 (clear-stream $_test-output-buffered-file->buffer) + 7671 # not bothering checking output + 7672 (check-next-stream-line-equal _test-error-stream "" "F - test-copy-deref-address: error message") + 7673 # . epilogue + 7674 5d/pop-to-ebp + 7675 c3/return + 7676 + 7677 test-copy-to-non-register: + 7678 # . prologue + 7679 55/push-ebp + 7680 89/<- %ebp 4/r32/esp + 7681 # setup + 7682 (clear-stream _test-input-stream) + 7683 (clear-stream $_test-input-buffered-file->buffer) + 7684 (clear-stream _test-output-stream) + 7685 (clear-stream $_test-output-buffered-file->buffer) + 7686 (clear-stream _test-error-stream) + 7687 (clear-stream $_test-error-buffered-file->buffer) + 7688 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7689 68/push 0/imm32 + 7690 68/push 0/imm32 + 7691 89/<- %edx 4/r32/esp + 7692 (tailor-exit-descriptor %edx 0x10) + 7693 # + 7694 (write _test-input-stream "fn foo {\n") + 7695 (write _test-input-stream " var x: int\n") + 7696 (write _test-input-stream " x <- copy 0\n") + 7697 (write _test-input-stream "}\n") + 7698 # convert + 7699 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7700 # registers except esp clobbered at this point + 7701 # restore ed + 7702 89/<- %edx 4/r32/esp + 7703 (flush _test-output-buffered-file) + 7704 (flush _test-error-buffered-file) + 7705 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7711 # check output + 7712 (check-stream-equal _test-output-stream "" "F - test-copy-to-non-register: output should be empty") + 7713 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: output 'x' not in a register" "F - test-copy-to-non-register: error message") + 7714 # check that stop(1) was called + 7715 (check-ints-equal *(edx+4) 2 "F - test-copy-to-non-register: exit status") + 7716 # don't restore from ebp + 7717 81 0/subop/add %esp 8/imm32 + 7718 # . epilogue + 7719 5d/pop-to-ebp + 7720 c3/return + 7721 + 7722 test-copy-non-scalar: + 7723 # . prologue + 7724 55/push-ebp + 7725 89/<- %ebp 4/r32/esp + 7726 # setup + 7727 (clear-stream _test-input-stream) + 7728 (clear-stream $_test-input-buffered-file->buffer) + 7729 (clear-stream _test-output-stream) + 7730 (clear-stream $_test-output-buffered-file->buffer) + 7731 (clear-stream _test-error-stream) + 7732 (clear-stream $_test-error-buffered-file->buffer) + 7733 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7734 68/push 0/imm32 + 7735 68/push 0/imm32 + 7736 89/<- %edx 4/r32/esp + 7737 (tailor-exit-descriptor %edx 0x10) + 7738 # + 7739 (write _test-input-stream "fn foo {\n") + 7740 (write _test-input-stream " var x: (handle int)\n") + 7741 (write _test-input-stream " var y/eax: int <- copy x\n") + 7742 (write _test-input-stream "}\n") + 7743 # convert + 7744 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7745 # registers except esp clobbered at this point + 7746 # restore ed + 7747 89/<- %edx 4/r32/esp + 7748 (flush _test-output-buffered-file) + 7749 (flush _test-error-buffered-file) + 7750 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7756 # check output + 7757 (check-stream-equal _test-output-stream "" "F - test-copy-non-scalar: output should be empty") + 7758 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy: 'x' is too large to fit in a register" "F - test-copy-non-scalar: error message") + 7759 # check that stop(1) was called + 7760 (check-ints-equal *(edx+4) 2 "F - test-copy-non-scalar: exit status") + 7761 # don't restore from ebp + 7762 81 0/subop/add %esp 8/imm32 + 7763 # . epilogue + 7764 5d/pop-to-ebp + 7765 c3/return + 7766 + 7767 test-copy-to-with-no-inout: + 7768 # . prologue + 7769 55/push-ebp + 7770 89/<- %ebp 4/r32/esp + 7771 # setup + 7772 (clear-stream _test-input-stream) + 7773 (clear-stream $_test-input-buffered-file->buffer) + 7774 (clear-stream _test-output-stream) + 7775 (clear-stream $_test-output-buffered-file->buffer) + 7776 (clear-stream _test-error-stream) + 7777 (clear-stream $_test-error-buffered-file->buffer) + 7778 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7779 68/push 0/imm32 + 7780 68/push 0/imm32 + 7781 89/<- %edx 4/r32/esp + 7782 (tailor-exit-descriptor %edx 0x10) 7783 # 7784 (write _test-input-stream "fn foo {\n") - 7785 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") - 7786 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") - 7787 (write _test-input-stream " compare y, x\n") - 7788 (write _test-input-stream "}\n") - 7789 # convert - 7790 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 7791 (flush _test-output-buffered-file) - 7792 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7798 # not bothering checking output - 7799 (check-next-stream-line-equal _test-error-stream "" "F - test-compare-address: error message") - 7800 # . epilogue - 7801 5d/pop-to-ebp - 7802 c3/return - 7803 - 7804 test-compare-deref-address: - 7805 # . prologue - 7806 55/push-ebp - 7807 89/<- %ebp 4/r32/esp - 7808 # setup - 7809 (clear-stream _test-input-stream) - 7810 (clear-stream $_test-input-buffered-file->buffer) - 7811 (clear-stream _test-output-stream) - 7812 (clear-stream $_test-output-buffered-file->buffer) - 7813 # - 7814 (write _test-input-stream "fn foo {\n") - 7815 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") - 7816 (write _test-input-stream " var y/ecx: (addr addr int) <- copy 0\n") - 7817 (write _test-input-stream " compare *y, x\n") - 7818 (write _test-input-stream "}\n") - 7819 # convert - 7820 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 7821 (flush _test-output-buffered-file) - 7822 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7828 # not bothering checking output - 7829 (check-next-stream-line-equal _test-error-stream "" "F - test-compare-deref-address: error message") - 7830 # . epilogue - 7831 5d/pop-to-ebp - 7832 c3/return - 7833 - 7834 test-compare-two-vars-in-memory: - 7835 # . prologue - 7836 55/push-ebp - 7837 89/<- %ebp 4/r32/esp - 7838 # setup - 7839 (clear-stream _test-input-stream) - 7840 (clear-stream $_test-input-buffered-file->buffer) - 7841 (clear-stream _test-output-stream) - 7842 (clear-stream $_test-output-buffered-file->buffer) - 7843 (clear-stream _test-error-stream) - 7844 (clear-stream $_test-error-buffered-file->buffer) - 7845 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7846 68/push 0/imm32 - 7847 68/push 0/imm32 - 7848 89/<- %edx 4/r32/esp - 7849 (tailor-exit-descriptor %edx 0x10) - 7850 # - 7851 (write _test-input-stream "fn foo {\n") - 7852 (write _test-input-stream " var x: boolean\n") - 7853 (write _test-input-stream " compare x, x\n") - 7854 (write _test-input-stream "}\n") - 7855 # convert - 7856 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7857 # registers except esp clobbered at this point - 7858 # restore ed - 7859 89/<- %edx 4/r32/esp - 7860 (flush _test-output-buffered-file) - 7861 (flush _test-error-buffered-file) - 7862 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7868 # check output - 7869 (check-stream-equal _test-output-stream "" "F - test-compare-two-vars-in-memory: output should be empty") - 7870 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: both inouts are in memory" "F - test-compare-two-vars-in-memory: error message") - 7871 # check that stop(1) was called - 7872 (check-ints-equal *(edx+4) 2 "F - test-compare-two-vars-in-memory: exit status") - 7873 # don't restore from ebp - 7874 81 0/subop/add %esp 8/imm32 - 7875 # . epilogue - 7876 5d/pop-to-ebp - 7877 c3/return - 7878 - 7879 test-compare-non-scalar: - 7880 # . prologue - 7881 55/push-ebp - 7882 89/<- %ebp 4/r32/esp - 7883 # setup - 7884 (clear-stream _test-input-stream) - 7885 (clear-stream $_test-input-buffered-file->buffer) - 7886 (clear-stream _test-output-stream) - 7887 (clear-stream $_test-output-buffered-file->buffer) - 7888 (clear-stream _test-error-stream) - 7889 (clear-stream $_test-error-buffered-file->buffer) - 7890 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7891 68/push 0/imm32 - 7892 68/push 0/imm32 - 7893 89/<- %edx 4/r32/esp - 7894 (tailor-exit-descriptor %edx 0x10) - 7895 # - 7896 (write _test-input-stream "fn foo {\n") - 7897 (write _test-input-stream " var x: (handle int)\n") - 7898 (write _test-input-stream " var y: int\n") - 7899 (write _test-input-stream " compare y, x\n") - 7900 (write _test-input-stream "}\n") - 7901 # convert - 7902 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7903 # registers except esp clobbered at this point - 7904 # restore ed - 7905 89/<- %edx 4/r32/esp - 7906 (flush _test-output-buffered-file) - 7907 (flush _test-error-buffered-file) - 7908 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7914 # check output - 7915 (check-stream-equal _test-output-stream "" "F - test-compare-non-scalar: output should be empty") - 7916 #? (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: 'x' is too large to compare" "F - test-compare-non-scalar: error message") - 7917 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: both inouts are in memory" "F - test-compare-non-scalar: error message") - 7918 # check that stop(1) was called - 7919 (check-ints-equal *(edx+4) 2 "F - test-compare-non-scalar: exit status") - 7920 # don't restore from ebp - 7921 81 0/subop/add %esp 8/imm32 - 7922 # . epilogue - 7923 5d/pop-to-ebp - 7924 c3/return - 7925 - 7926 test-address-with-no-inout: - 7927 # . prologue - 7928 55/push-ebp - 7929 89/<- %ebp 4/r32/esp - 7930 # setup - 7931 (clear-stream _test-input-stream) - 7932 (clear-stream $_test-input-buffered-file->buffer) - 7933 (clear-stream _test-output-stream) - 7934 (clear-stream $_test-output-buffered-file->buffer) - 7935 (clear-stream _test-error-stream) - 7936 (clear-stream $_test-error-buffered-file->buffer) - 7937 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7938 68/push 0/imm32 - 7939 68/push 0/imm32 - 7940 89/<- %edx 4/r32/esp - 7941 (tailor-exit-descriptor %edx 0x10) - 7942 # - 7943 (write _test-input-stream "fn foo {\n") - 7944 (write _test-input-stream " var x/eax: boolean <- address\n") - 7945 (write _test-input-stream "}\n") - 7946 # convert - 7947 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7948 # registers except esp clobbered at this point - 7949 # restore ed - 7950 89/<- %edx 4/r32/esp - 7951 (flush _test-output-buffered-file) - 7952 (flush _test-error-buffered-file) - 7953 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 7959 # check output - 7960 (check-stream-equal _test-output-stream "" "F - test-address-with-no-inout: output should be empty") - 7961 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' expects an inout" "F - test-address-with-no-inout: error message") - 7962 # check that stop(1) was called - 7963 (check-ints-equal *(edx+4) 2 "F - test-address-with-no-inout: exit status") - 7964 # don't restore from ebp - 7965 81 0/subop/add %esp 8/imm32 - 7966 # . epilogue - 7967 5d/pop-to-ebp - 7968 c3/return - 7969 - 7970 test-address-with-multiple-inouts: - 7971 # . prologue - 7972 55/push-ebp - 7973 89/<- %ebp 4/r32/esp - 7974 # setup - 7975 (clear-stream _test-input-stream) - 7976 (clear-stream $_test-input-buffered-file->buffer) - 7977 (clear-stream _test-output-stream) - 7978 (clear-stream $_test-output-buffered-file->buffer) - 7979 (clear-stream _test-error-stream) - 7980 (clear-stream $_test-error-buffered-file->buffer) - 7981 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 7982 68/push 0/imm32 - 7983 68/push 0/imm32 - 7984 89/<- %edx 4/r32/esp - 7985 (tailor-exit-descriptor %edx 0x10) - 7986 # - 7987 (write _test-input-stream "fn foo {\n") - 7988 (write _test-input-stream " var x/eax: boolean <- address 0, 0\n") - 7989 (write _test-input-stream "}\n") - 7990 # convert - 7991 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 7992 # registers except esp clobbered at this point - 7993 # restore ed - 7994 89/<- %edx 4/r32/esp - 7995 (flush _test-output-buffered-file) - 7996 (flush _test-error-buffered-file) - 7997 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8003 # check output - 8004 (check-stream-equal _test-output-stream "" "F - test-address-with-multiple-inouts: output should be empty") - 8005 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' must have just one inout" "F - test-address-with-multiple-inouts: error message") - 8006 # check that stop(1) was called - 8007 (check-ints-equal *(edx+4) 2 "F - test-address-with-multiple-inouts: exit status") - 8008 # don't restore from ebp - 8009 81 0/subop/add %esp 8/imm32 - 8010 # . epilogue - 8011 5d/pop-to-ebp - 8012 c3/return - 8013 - 8014 test-address-with-no-output: - 8015 # . prologue - 8016 55/push-ebp - 8017 89/<- %ebp 4/r32/esp - 8018 # setup - 8019 (clear-stream _test-input-stream) - 8020 (clear-stream $_test-input-buffered-file->buffer) - 8021 (clear-stream _test-output-stream) - 8022 (clear-stream $_test-output-buffered-file->buffer) - 8023 (clear-stream _test-error-stream) - 8024 (clear-stream $_test-error-buffered-file->buffer) - 8025 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8026 68/push 0/imm32 - 8027 68/push 0/imm32 - 8028 89/<- %edx 4/r32/esp - 8029 (tailor-exit-descriptor %edx 0x10) - 8030 # - 8031 (write _test-input-stream "fn foo {\n") - 8032 (write _test-input-stream " address 0\n") - 8033 (write _test-input-stream "}\n") - 8034 # convert - 8035 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8036 # registers except esp clobbered at this point - 8037 # restore ed - 8038 89/<- %edx 4/r32/esp - 8039 (flush _test-output-buffered-file) - 8040 (flush _test-error-buffered-file) - 8041 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8047 # check output - 8048 (check-stream-equal _test-output-stream "" "F - test-address-with-no-output: output should be empty") - 8049 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' expects an output" "F - test-address-with-no-output: error message") - 8050 # check that stop(1) was called - 8051 (check-ints-equal *(edx+4) 2 "F - test-address-with-no-output: exit status") - 8052 # don't restore from ebp - 8053 81 0/subop/add %esp 8/imm32 - 8054 # . epilogue - 8055 5d/pop-to-ebp - 8056 c3/return - 8057 - 8058 test-address-with-multiple-outputs: - 8059 # . prologue - 8060 55/push-ebp - 8061 89/<- %ebp 4/r32/esp - 8062 # setup - 8063 (clear-stream _test-input-stream) - 8064 (clear-stream $_test-input-buffered-file->buffer) - 8065 (clear-stream _test-output-stream) - 8066 (clear-stream $_test-output-buffered-file->buffer) - 8067 (clear-stream _test-error-stream) - 8068 (clear-stream $_test-error-buffered-file->buffer) - 8069 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8070 68/push 0/imm32 - 8071 68/push 0/imm32 - 8072 89/<- %edx 4/r32/esp - 8073 (tailor-exit-descriptor %edx 0x10) - 8074 # - 8075 (write _test-input-stream "fn foo {\n") - 8076 (write _test-input-stream " var x/eax: boolean <- copy 0\n") - 8077 (write _test-input-stream " var y/ecx: boolean <- copy 0\n") - 8078 (write _test-input-stream " x, y <- address 0\n") - 8079 (write _test-input-stream "}\n") - 8080 # convert - 8081 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8082 # registers except esp clobbered at this point - 8083 # restore ed - 8084 89/<- %edx 4/r32/esp - 8085 (flush _test-output-buffered-file) - 8086 (flush _test-error-buffered-file) - 8087 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8093 # check output - 8094 (check-stream-equal _test-output-stream "" "F - test-address-with-multiple-outputs: output should be empty") - 8095 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' must have just one output" "F - test-address-with-multiple-outputs: error message") - 8096 # check that stop(1) was called - 8097 (check-ints-equal *(edx+4) 2 "F - test-address-with-multiple-outputs: exit status") - 8098 # don't restore from ebp - 8099 81 0/subop/add %esp 8/imm32 - 8100 # . epilogue - 8101 5d/pop-to-ebp - 8102 c3/return - 8103 - 8104 # silly but it works - 8105 test-address-of-deref: - 8106 # . prologue - 8107 55/push-ebp - 8108 89/<- %ebp 4/r32/esp - 8109 # setup - 8110 (clear-stream _test-input-stream) - 8111 (clear-stream $_test-input-buffered-file->buffer) - 8112 (clear-stream _test-output-stream) - 8113 (clear-stream $_test-output-buffered-file->buffer) - 8114 # - 8115 (write _test-input-stream "fn foo {\n") - 8116 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") - 8117 (write _test-input-stream " var y/ecx: (addr int) <- address *x\n") - 8118 (write _test-input-stream "}\n") - 8119 # convert - 8120 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 8121 (flush _test-output-buffered-file) - 8122 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8128 # not bothering checking output - 8129 (check-next-stream-line-equal _test-error-stream "" "F - test-address-of-deref: error message") - 8130 # . epilogue - 8131 5d/pop-to-ebp - 8132 c3/return - 8133 - 8134 test-address-to-non-register: - 8135 # . prologue - 8136 55/push-ebp - 8137 89/<- %ebp 4/r32/esp - 8138 # setup - 8139 (clear-stream _test-input-stream) - 8140 (clear-stream $_test-input-buffered-file->buffer) - 8141 (clear-stream _test-output-stream) - 8142 (clear-stream $_test-output-buffered-file->buffer) - 8143 (clear-stream _test-error-stream) - 8144 (clear-stream $_test-error-buffered-file->buffer) - 8145 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8146 68/push 0/imm32 - 8147 68/push 0/imm32 - 8148 89/<- %edx 4/r32/esp - 8149 (tailor-exit-descriptor %edx 0x10) - 8150 # - 8151 (write _test-input-stream "fn foo {\n") - 8152 (write _test-input-stream " var x: (addr int)\n") - 8153 (write _test-input-stream " x <- address 0\n") - 8154 (write _test-input-stream "}\n") - 8155 # convert - 8156 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8157 # registers except esp clobbered at this point - 8158 # restore ed - 8159 89/<- %edx 4/r32/esp - 8160 (flush _test-output-buffered-file) - 8161 (flush _test-error-buffered-file) - 8162 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8168 # check output - 8169 (check-stream-equal _test-output-stream "" "F - test-address-to-non-register: output should be empty") - 8170 (check-next-stream-line-equal _test-error-stream "fn foo: stmt address: output 'x' not in a register" "F - test-address-to-non-register: error message") - 8171 # check that stop(1) was called - 8172 (check-ints-equal *(edx+4) 2 "F - test-address-to-non-register: exit status") - 8173 # don't restore from ebp - 8174 81 0/subop/add %esp 8/imm32 - 8175 # . epilogue - 8176 5d/pop-to-ebp - 8177 c3/return - 8178 - 8179 test-address-with-wrong-type: - 8180 # . prologue - 8181 55/push-ebp - 8182 89/<- %ebp 4/r32/esp - 8183 # setup - 8184 (clear-stream _test-input-stream) - 8185 (clear-stream $_test-input-buffered-file->buffer) - 8186 (clear-stream _test-output-stream) - 8187 (clear-stream $_test-output-buffered-file->buffer) - 8188 (clear-stream _test-error-stream) - 8189 (clear-stream $_test-error-buffered-file->buffer) - 8190 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8191 68/push 0/imm32 - 8192 68/push 0/imm32 - 8193 89/<- %edx 4/r32/esp - 8194 (tailor-exit-descriptor %edx 0x10) - 8195 # - 8196 (write _test-input-stream "fn foo {\n") - 8197 (write _test-input-stream " var x: int\n") - 8198 (write _test-input-stream " var y/eax: (addr boolean) <- address x\n") - 8199 (write _test-input-stream "}\n") - 8200 # convert - 8201 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8202 # registers except esp clobbered at this point - 8203 # restore ed - 8204 89/<- %edx 4/r32/esp - 8205 (flush _test-output-buffered-file) - 8206 (flush _test-error-buffered-file) - 8207 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8213 # check output - 8214 (check-stream-equal _test-output-stream "" "F - test-address-with-wrong-type: output should be empty") - 8215 (check-next-stream-line-equal _test-error-stream "fn foo: stmt address: output 'y' cannot hold address of 'x'" "F - test-address-with-wrong-type: error message") - 8216 # check that stop(1) was called - 8217 (check-ints-equal *(edx+4) 2 "F - test-address-with-wrong-type: exit status") - 8218 # don't restore from ebp - 8219 81 0/subop/add %esp 8/imm32 - 8220 # . epilogue - 8221 5d/pop-to-ebp - 8222 c3/return - 8223 - 8224 test-address-with-right-type-for-array: - 8225 # . prologue - 8226 55/push-ebp - 8227 89/<- %ebp 4/r32/esp - 8228 # setup - 8229 (clear-stream _test-input-stream) - 8230 (clear-stream $_test-input-buffered-file->buffer) - 8231 (clear-stream _test-output-stream) - 8232 (clear-stream $_test-output-buffered-file->buffer) - 8233 # - 8234 (write _test-input-stream "fn foo {\n") - 8235 (write _test-input-stream " var x: (array int 3)\n") - 8236 (write _test-input-stream " var y/eax: (addr array int) <- address x\n") - 8237 (write _test-input-stream "}\n") - 8238 # convert - 8239 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 8240 (flush _test-output-buffered-file) - 8241 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8247 # no error - 8248 (check-next-stream-line-equal _test-error-stream "" "F - test-address-with-right-type-for-array: error message") - 8249 # don't bother checking output - 8250 # . epilogue - 8251 89/<- %esp 5/r32/ebp - 8252 5d/pop-to-ebp - 8253 c3/return - 8254 - 8255 test-address-with-right-type-for-stream: - 8256 # . prologue - 8257 55/push-ebp - 8258 89/<- %ebp 4/r32/esp - 8259 # setup - 8260 (clear-stream _test-input-stream) - 8261 (clear-stream $_test-input-buffered-file->buffer) - 8262 (clear-stream _test-output-stream) - 8263 (clear-stream $_test-output-buffered-file->buffer) - 8264 # - 8265 (write _test-input-stream "fn foo {\n") - 8266 (write _test-input-stream " var x: (stream int 3)\n") - 8267 (write _test-input-stream " var y/eax: (addr stream int) <- address x\n") - 8268 (write _test-input-stream "}\n") - 8269 # convert - 8270 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 8271 (flush _test-output-buffered-file) - 8272 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8278 # no error - 8279 (check-next-stream-line-equal _test-error-stream "" "F - test-address-with-right-type-for-stream: error message") - 8280 # don't bother checking output - 8281 # . epilogue - 8282 89/<- %esp 5/r32/ebp - 8283 5d/pop-to-ebp - 8284 c3/return - 8285 - 8286 test-get-with-wrong-field: - 8287 # . prologue - 8288 55/push-ebp - 8289 89/<- %ebp 4/r32/esp - 8290 # setup - 8291 (clear-stream _test-input-stream) - 8292 (clear-stream $_test-input-buffered-file->buffer) - 8293 (clear-stream _test-output-stream) - 8294 (clear-stream $_test-output-buffered-file->buffer) - 8295 (clear-stream _test-error-stream) - 8296 (clear-stream $_test-error-buffered-file->buffer) - 8297 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8298 68/push 0/imm32 - 8299 68/push 0/imm32 - 8300 89/<- %edx 4/r32/esp - 8301 (tailor-exit-descriptor %edx 0x10) - 8302 # - 8303 (write _test-input-stream "fn foo {\n") - 8304 (write _test-input-stream " var a: t\n") - 8305 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 8306 (write _test-input-stream "}\n") - 8307 (write _test-input-stream "type t {\n") - 8308 (write _test-input-stream " x: int\n") - 8309 (write _test-input-stream "}\n") - 8310 # convert - 8311 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8312 # registers except esp clobbered at this point - 8313 # restore ed - 8314 89/<- %edx 4/r32/esp - 8315 (flush _test-output-buffered-file) - 8316 (flush _test-error-buffered-file) - 8317 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8323 # check output - 8324 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-field: output should be empty") - 8325 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'y'" "F - test-get-with-wrong-field: error message") - 8326 # check that stop(1) was called - 8327 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-field: exit status") - 8328 # don't restore from ebp - 8329 81 0/subop/add %esp 8/imm32 - 8330 # . epilogue - 8331 5d/pop-to-ebp - 8332 c3/return - 8333 - 8334 test-get-with-wrong-base-type: - 8335 # . prologue - 8336 55/push-ebp - 8337 89/<- %ebp 4/r32/esp - 8338 # setup - 8339 (clear-stream _test-input-stream) - 8340 (clear-stream $_test-input-buffered-file->buffer) - 8341 (clear-stream _test-output-stream) - 8342 (clear-stream $_test-output-buffered-file->buffer) - 8343 (clear-stream _test-error-stream) - 8344 (clear-stream $_test-error-buffered-file->buffer) - 8345 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8346 68/push 0/imm32 - 8347 68/push 0/imm32 - 8348 89/<- %edx 4/r32/esp - 8349 (tailor-exit-descriptor %edx 0x10) - 8350 # - 8351 (write _test-input-stream "fn foo {\n") - 8352 (write _test-input-stream " var a: int\n") - 8353 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 8354 (write _test-input-stream "}\n") - 8355 # convert - 8356 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8357 # registers except esp clobbered at this point - 8358 # restore ed - 8359 89/<- %edx 4/r32/esp - 8360 (flush _test-output-buffered-file) - 8361 (flush _test-error-buffered-file) - 8362 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8368 # check output - 8369 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type: output should be empty") - 8370 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' must have a 'type' definition" "F - test-get-with-wrong-base-type: error message") - 8371 # check that stop(1) was called - 8372 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type: exit status") - 8373 # don't restore from ebp - 8374 81 0/subop/add %esp 8/imm32 - 8375 # . epilogue - 8376 5d/pop-to-ebp - 8377 c3/return - 8378 - 8379 test-get-with-wrong-base-type-2: - 8380 # . prologue - 8381 55/push-ebp - 8382 89/<- %ebp 4/r32/esp - 8383 # setup - 8384 (clear-stream _test-input-stream) - 8385 (clear-stream $_test-input-buffered-file->buffer) - 8386 (clear-stream _test-output-stream) - 8387 (clear-stream $_test-output-buffered-file->buffer) - 8388 (clear-stream _test-error-stream) - 8389 (clear-stream $_test-error-buffered-file->buffer) - 8390 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8391 68/push 0/imm32 - 8392 68/push 0/imm32 - 8393 89/<- %edx 4/r32/esp - 8394 (tailor-exit-descriptor %edx 0x10) - 8395 # - 8396 (write _test-input-stream "fn foo {\n") - 8397 (write _test-input-stream " var a: (addr t)\n") - 8398 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 8399 (write _test-input-stream "}\n") - 8400 (write _test-input-stream "type t {\n") - 8401 (write _test-input-stream " x: int\n") - 8402 (write _test-input-stream "}\n") - 8403 # convert - 8404 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8405 # registers except esp clobbered at this point - 8406 # restore ed - 8407 89/<- %edx 4/r32/esp - 8408 (flush _test-output-buffered-file) - 8409 (flush _test-error-buffered-file) - 8410 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8416 # check output - 8417 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type-2: output should be empty") - 8418 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' is an 'addr' type, and so must live in a register" "F - test-get-with-wrong-base-type-2: error message") - 8419 # check that stop(1) was called - 8420 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type-2: exit status") - 8421 # don't restore from ebp - 8422 81 0/subop/add %esp 8/imm32 - 8423 # . epilogue - 8424 5d/pop-to-ebp - 8425 c3/return - 8426 - 8427 test-get-with-wrong-base-type-3: - 8428 # . prologue - 8429 55/push-ebp - 8430 89/<- %ebp 4/r32/esp - 8431 # setup - 8432 (clear-stream _test-input-stream) - 8433 (clear-stream $_test-input-buffered-file->buffer) - 8434 (clear-stream _test-output-stream) - 8435 (clear-stream $_test-output-buffered-file->buffer) - 8436 (clear-stream _test-error-stream) - 8437 (clear-stream $_test-error-buffered-file->buffer) - 8438 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8439 68/push 0/imm32 - 8440 68/push 0/imm32 - 8441 89/<- %edx 4/r32/esp - 8442 (tailor-exit-descriptor %edx 0x10) - 8443 # - 8444 (write _test-input-stream "fn foo {\n") - 8445 (write _test-input-stream " var a: (handle int)\n") - 8446 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") - 8447 (write _test-input-stream "}\n") - 8448 # convert - 8449 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8450 # registers except esp clobbered at this point - 8451 # restore ed - 8452 89/<- %edx 4/r32/esp - 8453 (flush _test-output-buffered-file) - 8454 (flush _test-error-buffered-file) - 8455 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8461 # check output - 8462 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type-3: output should be empty") - 8463 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' must have a 'type' definition" "F - test-get-with-wrong-base-type-3: error message") - 8464 # check that stop(1) was called - 8465 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type-3: exit status") - 8466 # don't restore from ebp - 8467 81 0/subop/add %esp 8/imm32 - 8468 # . epilogue - 8469 5d/pop-to-ebp - 8470 c3/return - 8471 - 8472 test-get-with-wrong-offset-type: - 8473 # . prologue - 8474 55/push-ebp - 8475 89/<- %ebp 4/r32/esp - 8476 # setup - 8477 (clear-stream _test-input-stream) - 8478 (clear-stream $_test-input-buffered-file->buffer) - 8479 (clear-stream _test-output-stream) - 8480 (clear-stream $_test-output-buffered-file->buffer) - 8481 (clear-stream _test-error-stream) - 8482 (clear-stream $_test-error-buffered-file->buffer) - 8483 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8484 68/push 0/imm32 - 8485 68/push 0/imm32 - 8486 89/<- %edx 4/r32/esp - 8487 (tailor-exit-descriptor %edx 0x10) - 8488 # - 8489 (write _test-input-stream "fn foo {\n") - 8490 (write _test-input-stream " var a: t\n") - 8491 (write _test-input-stream " var b: int\n") - 8492 (write _test-input-stream " var c/ecx: (addr int) <- get a, b\n") - 8493 (write _test-input-stream "}\n") - 8494 (write _test-input-stream "type t {\n") - 8495 (write _test-input-stream " x: int\n") - 8496 (write _test-input-stream "}\n") - 8497 # convert - 8498 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8499 # registers except esp clobbered at this point - 8500 # restore ed - 8501 89/<- %edx 4/r32/esp - 8502 (flush _test-output-buffered-file) - 8503 (flush _test-error-buffered-file) - 8504 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8510 # check output - 8511 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-offset-type: output should be empty") - 8512 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'b'" "F - test-get-with-wrong-offset-type: error message") - 8513 # check that stop(1) was called - 8514 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-offset-type: exit status") - 8515 # don't restore from ebp - 8516 81 0/subop/add %esp 8/imm32 - 8517 # . epilogue - 8518 5d/pop-to-ebp - 8519 c3/return - 8520 - 8521 test-get-with-wrong-output-type: - 8522 # . prologue - 8523 55/push-ebp - 8524 89/<- %ebp 4/r32/esp - 8525 # setup - 8526 (clear-stream _test-input-stream) - 8527 (clear-stream $_test-input-buffered-file->buffer) - 8528 (clear-stream _test-output-stream) - 8529 (clear-stream $_test-output-buffered-file->buffer) - 8530 (clear-stream _test-error-stream) - 8531 (clear-stream $_test-error-buffered-file->buffer) - 8532 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8533 68/push 0/imm32 - 8534 68/push 0/imm32 - 8535 89/<- %edx 4/r32/esp - 8536 (tailor-exit-descriptor %edx 0x10) - 8537 # - 8538 (write _test-input-stream "fn foo {\n") - 8539 (write _test-input-stream " var a: t\n") - 8540 (write _test-input-stream " var c: (addr int)\n") - 8541 (write _test-input-stream " c <- get a, x\n") - 8542 (write _test-input-stream "}\n") - 8543 (write _test-input-stream "type t {\n") - 8544 (write _test-input-stream " x: int\n") - 8545 (write _test-input-stream "}\n") - 8546 # convert - 8547 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8548 # registers except esp clobbered at this point - 8549 # restore ed - 8550 89/<- %edx 4/r32/esp - 8551 (flush _test-output-buffered-file) - 8552 (flush _test-error-buffered-file) - 8553 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8559 # check output - 8560 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type: output should be empty") - 8561 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output 'c' is not in a register" "F - test-get-with-wrong-output-type: error message") - 8562 # check that stop(1) was called - 8563 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type: exit status") - 8564 # don't restore from ebp - 8565 81 0/subop/add %esp 8/imm32 - 8566 # . epilogue - 8567 5d/pop-to-ebp - 8568 c3/return - 8569 - 8570 test-get-with-wrong-output-type-2: - 8571 # . prologue - 8572 55/push-ebp - 8573 89/<- %ebp 4/r32/esp - 8574 # setup - 8575 (clear-stream _test-input-stream) - 8576 (clear-stream $_test-input-buffered-file->buffer) - 8577 (clear-stream _test-output-stream) - 8578 (clear-stream $_test-output-buffered-file->buffer) - 8579 (clear-stream _test-error-stream) - 8580 (clear-stream $_test-error-buffered-file->buffer) - 8581 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8582 68/push 0/imm32 - 8583 68/push 0/imm32 - 8584 89/<- %edx 4/r32/esp - 8585 (tailor-exit-descriptor %edx 0x10) - 8586 # - 8587 (write _test-input-stream "fn foo {\n") - 8588 (write _test-input-stream " var a: t\n") - 8589 (write _test-input-stream " var c/ecx: int <- get a, x\n") - 8590 (write _test-input-stream "}\n") - 8591 (write _test-input-stream "type t {\n") - 8592 (write _test-input-stream " x: int\n") - 8593 (write _test-input-stream "}\n") - 8594 # convert - 8595 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8596 # registers except esp clobbered at this point - 8597 # restore ed - 8598 89/<- %edx 4/r32/esp - 8599 (flush _test-output-buffered-file) - 8600 (flush _test-error-buffered-file) - 8601 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8607 # check output - 8608 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-2: output should be empty") - 8609 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an addr" "F - test-get-with-wrong-output-type-2: error message") - 8610 # check that stop(1) was called - 8611 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-2: exit status") - 8612 # don't restore from ebp - 8613 81 0/subop/add %esp 8/imm32 - 8614 # . epilogue - 8615 5d/pop-to-ebp - 8616 c3/return - 8617 - 8618 test-get-with-wrong-output-type-3: - 8619 # . prologue - 8620 55/push-ebp - 8621 89/<- %ebp 4/r32/esp - 8622 # setup - 8623 (clear-stream _test-input-stream) - 8624 (clear-stream $_test-input-buffered-file->buffer) - 8625 (clear-stream _test-output-stream) - 8626 (clear-stream $_test-output-buffered-file->buffer) - 8627 (clear-stream _test-error-stream) - 8628 (clear-stream $_test-error-buffered-file->buffer) - 8629 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8630 68/push 0/imm32 - 8631 68/push 0/imm32 - 8632 89/<- %edx 4/r32/esp - 8633 (tailor-exit-descriptor %edx 0x10) - 8634 # - 8635 (write _test-input-stream "fn foo {\n") - 8636 (write _test-input-stream " var a: t\n") - 8637 (write _test-input-stream " var c/ecx: (array int) <- get a, x\n") - 8638 (write _test-input-stream "}\n") - 8639 (write _test-input-stream "type t {\n") - 8640 (write _test-input-stream " x: int\n") - 8641 (write _test-input-stream "}\n") - 8642 # convert - 8643 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8644 # registers except esp clobbered at this point - 8645 # restore ed - 8646 89/<- %edx 4/r32/esp - 8647 (flush _test-output-buffered-file) - 8648 (flush _test-error-buffered-file) - 8649 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8655 # check output - 8656 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-3: output should be empty") - 8657 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an addr" "F - test-get-with-wrong-output-type-3: error message") - 8658 # check that stop(1) was called - 8659 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-3: exit status") - 8660 # don't restore from ebp - 8661 81 0/subop/add %esp 8/imm32 - 8662 # . epilogue - 8663 5d/pop-to-ebp - 8664 c3/return - 8665 - 8666 test-get-with-wrong-output-type-4: - 8667 # . prologue - 8668 55/push-ebp - 8669 89/<- %ebp 4/r32/esp - 8670 # setup - 8671 (clear-stream _test-input-stream) - 8672 (clear-stream $_test-input-buffered-file->buffer) - 8673 (clear-stream _test-output-stream) - 8674 (clear-stream $_test-output-buffered-file->buffer) - 8675 (clear-stream _test-error-stream) - 8676 (clear-stream $_test-error-buffered-file->buffer) - 8677 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8678 68/push 0/imm32 - 8679 68/push 0/imm32 - 8680 89/<- %edx 4/r32/esp - 8681 (tailor-exit-descriptor %edx 0x10) + 7785 (write _test-input-stream " copy-to\n") + 7786 (write _test-input-stream "}\n") + 7787 # convert + 7788 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7789 # registers except esp clobbered at this point + 7790 # restore ed + 7791 89/<- %edx 4/r32/esp + 7792 (flush _test-output-buffered-file) + 7793 (flush _test-error-buffered-file) + 7794 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7800 # check output + 7801 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-no-inout: output should be empty") + 7802 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must have two inouts" "F - test-copy-to-with-no-inout: error message") + 7803 # check that stop(1) was called + 7804 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-no-inout: exit status") + 7805 # don't restore from ebp + 7806 81 0/subop/add %esp 8/imm32 + 7807 # . epilogue + 7808 5d/pop-to-ebp + 7809 c3/return + 7810 + 7811 test-copy-to-with-no-input: + 7812 # . prologue + 7813 55/push-ebp + 7814 89/<- %ebp 4/r32/esp + 7815 # setup + 7816 (clear-stream _test-input-stream) + 7817 (clear-stream $_test-input-buffered-file->buffer) + 7818 (clear-stream _test-output-stream) + 7819 (clear-stream $_test-output-buffered-file->buffer) + 7820 (clear-stream _test-error-stream) + 7821 (clear-stream $_test-error-buffered-file->buffer) + 7822 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7823 68/push 0/imm32 + 7824 68/push 0/imm32 + 7825 89/<- %edx 4/r32/esp + 7826 (tailor-exit-descriptor %edx 0x10) + 7827 # + 7828 (write _test-input-stream "fn foo {\n") + 7829 (write _test-input-stream " var x: boolean\n") + 7830 (write _test-input-stream " copy-to x\n") + 7831 (write _test-input-stream "}\n") + 7832 # convert + 7833 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7834 # registers except esp clobbered at this point + 7835 # restore ed + 7836 89/<- %edx 4/r32/esp + 7837 (flush _test-output-buffered-file) + 7838 (flush _test-error-buffered-file) + 7839 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7845 # check output + 7846 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-no-input: output should be empty") + 7847 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must have two inouts" "F - test-copy-to-with-no-input: error message") + 7848 # check that stop(1) was called + 7849 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-no-input: exit status") + 7850 # don't restore from ebp + 7851 81 0/subop/add %esp 8/imm32 + 7852 # . epilogue + 7853 5d/pop-to-ebp + 7854 c3/return + 7855 + 7856 test-copy-to-with-no-register: + 7857 # . prologue + 7858 55/push-ebp + 7859 89/<- %ebp 4/r32/esp + 7860 # setup + 7861 (clear-stream _test-input-stream) + 7862 (clear-stream $_test-input-buffered-file->buffer) + 7863 (clear-stream _test-output-stream) + 7864 (clear-stream $_test-output-buffered-file->buffer) + 7865 (clear-stream _test-error-stream) + 7866 (clear-stream $_test-error-buffered-file->buffer) + 7867 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7868 68/push 0/imm32 + 7869 68/push 0/imm32 + 7870 89/<- %edx 4/r32/esp + 7871 (tailor-exit-descriptor %edx 0x10) + 7872 # + 7873 (write _test-input-stream "fn foo {\n") + 7874 (write _test-input-stream " var x: boolean\n") + 7875 (write _test-input-stream " copy-to x, x\n") + 7876 (write _test-input-stream "}\n") + 7877 # convert + 7878 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7879 # registers except esp clobbered at this point + 7880 # restore ed + 7881 89/<- %edx 4/r32/esp + 7882 (flush _test-output-buffered-file) + 7883 (flush _test-error-buffered-file) + 7884 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7890 # check output + 7891 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-no-register: output should be empty") + 7892 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: source (second inout) is in memory" "F - test-copy-to-with-no-register: error message") + 7893 # check that stop(1) was called + 7894 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-no-register: exit status") + 7895 # don't restore from ebp + 7896 81 0/subop/add %esp 8/imm32 + 7897 # . epilogue + 7898 5d/pop-to-ebp + 7899 c3/return + 7900 + 7901 test-copy-to-with-too-many-inouts: + 7902 # . prologue + 7903 55/push-ebp + 7904 89/<- %ebp 4/r32/esp + 7905 # setup + 7906 (clear-stream _test-input-stream) + 7907 (clear-stream $_test-input-buffered-file->buffer) + 7908 (clear-stream _test-output-stream) + 7909 (clear-stream $_test-output-buffered-file->buffer) + 7910 (clear-stream _test-error-stream) + 7911 (clear-stream $_test-error-buffered-file->buffer) + 7912 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7913 68/push 0/imm32 + 7914 68/push 0/imm32 + 7915 89/<- %edx 4/r32/esp + 7916 (tailor-exit-descriptor %edx 0x10) + 7917 # + 7918 (write _test-input-stream "fn foo {\n") + 7919 (write _test-input-stream " var x: boolean\n") + 7920 (write _test-input-stream " copy-to x, 0, 0\n") + 7921 (write _test-input-stream "}\n") + 7922 # convert + 7923 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7924 # registers except esp clobbered at this point + 7925 # restore ed + 7926 89/<- %edx 4/r32/esp + 7927 (flush _test-output-buffered-file) + 7928 (flush _test-error-buffered-file) + 7929 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7935 # check output + 7936 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-too-many-inouts: output should be empty") + 7937 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must have two inouts" "F - test-copy-to-with-too-many-inouts: error message") + 7938 # check that stop(1) was called + 7939 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-too-many-inouts: exit status") + 7940 # don't restore from ebp + 7941 81 0/subop/add %esp 8/imm32 + 7942 # . epilogue + 7943 5d/pop-to-ebp + 7944 c3/return + 7945 + 7946 test-copy-to-with-output: + 7947 # . prologue + 7948 55/push-ebp + 7949 89/<- %ebp 4/r32/esp + 7950 # setup + 7951 (clear-stream _test-input-stream) + 7952 (clear-stream $_test-input-buffered-file->buffer) + 7953 (clear-stream _test-output-stream) + 7954 (clear-stream $_test-output-buffered-file->buffer) + 7955 (clear-stream _test-error-stream) + 7956 (clear-stream $_test-error-buffered-file->buffer) + 7957 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 7958 68/push 0/imm32 + 7959 68/push 0/imm32 + 7960 89/<- %edx 4/r32/esp + 7961 (tailor-exit-descriptor %edx 0x10) + 7962 # + 7963 (write _test-input-stream "fn foo {\n") + 7964 (write _test-input-stream " var x/eax: boolean <- copy 0\n") + 7965 (write _test-input-stream " var y/ecx: boolean <- copy 0\n") + 7966 (write _test-input-stream " x <- copy-to y, 0\n") + 7967 (write _test-input-stream "}\n") + 7968 # convert + 7969 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 7970 # registers except esp clobbered at this point + 7971 # restore ed + 7972 89/<- %edx 4/r32/esp + 7973 (flush _test-output-buffered-file) + 7974 (flush _test-error-buffered-file) + 7975 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 7981 # check output + 7982 (check-stream-equal _test-output-stream "" "F - test-copy-to-with-output: output should be empty") + 7983 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-to' must not have any outputs" "F - test-copy-to-with-output: error message") + 7984 # check that stop(1) was called + 7985 (check-ints-equal *(edx+4) 2 "F - test-copy-to-with-output: exit status") + 7986 # don't restore from ebp + 7987 81 0/subop/add %esp 8/imm32 + 7988 # . epilogue + 7989 5d/pop-to-ebp + 7990 c3/return + 7991 + 7992 test-copy-to-invalid-value-to-address: + 7993 # . prologue + 7994 55/push-ebp + 7995 89/<- %ebp 4/r32/esp + 7996 # setup + 7997 (clear-stream _test-input-stream) + 7998 (clear-stream $_test-input-buffered-file->buffer) + 7999 (clear-stream _test-output-stream) + 8000 (clear-stream $_test-output-buffered-file->buffer) + 8001 (clear-stream _test-error-stream) + 8002 (clear-stream $_test-error-buffered-file->buffer) + 8003 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8004 68/push 0/imm32 + 8005 68/push 0/imm32 + 8006 89/<- %edx 4/r32/esp + 8007 (tailor-exit-descriptor %edx 0x10) + 8008 # + 8009 (write _test-input-stream "fn foo {\n") + 8010 (write _test-input-stream " var x/eax: int <- copy 0\n") + 8011 (write _test-input-stream " var y: (addr int)\n") + 8012 (write _test-input-stream " copy-to y, x\n") + 8013 (write _test-input-stream "}\n") + 8014 # convert + 8015 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8016 # registers except esp clobbered at this point + 8017 # restore ed + 8018 89/<- %edx 4/r32/esp + 8019 (flush _test-output-buffered-file) + 8020 (flush _test-error-buffered-file) + 8021 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8027 # check output + 8028 (check-stream-equal _test-output-stream "" "F - test-copy-to-invalid-value-to-address: output should be empty") + 8029 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: 'y' must be a non-addr non-offset scalar" "F - test-copy-to-invalid-value-to-address: error message") + 8030 # check that stop(1) was called + 8031 (check-ints-equal *(edx+4) 2 "F - test-copy-to-invalid-value-to-address: exit status") + 8032 # don't restore from ebp + 8033 81 0/subop/add %esp 8/imm32 + 8034 # . epilogue + 8035 5d/pop-to-ebp + 8036 c3/return + 8037 + 8038 test-copy-to-deref-address: + 8039 # . prologue + 8040 55/push-ebp + 8041 89/<- %ebp 4/r32/esp + 8042 # setup + 8043 (clear-stream _test-input-stream) + 8044 (clear-stream $_test-input-buffered-file->buffer) + 8045 (clear-stream _test-output-stream) + 8046 (clear-stream $_test-output-buffered-file->buffer) + 8047 # + 8048 (write _test-input-stream "fn foo {\n") + 8049 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") + 8050 (write _test-input-stream " var y/ecx: (addr addr int) <- copy 0\n") + 8051 (write _test-input-stream " copy-to *y, x\n") + 8052 (write _test-input-stream "}\n") + 8053 # convert + 8054 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 8055 (flush _test-output-buffered-file) + 8056 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8062 # not bothering checking output + 8063 (check-next-stream-line-equal _test-error-stream "" "F - test-copy-to-deref-address: error message") + 8064 # . epilogue + 8065 5d/pop-to-ebp + 8066 c3/return + 8067 + 8068 test-copy-to-non-scalar: + 8069 # . prologue + 8070 55/push-ebp + 8071 89/<- %ebp 4/r32/esp + 8072 # setup + 8073 (clear-stream _test-input-stream) + 8074 (clear-stream $_test-input-buffered-file->buffer) + 8075 (clear-stream _test-output-stream) + 8076 (clear-stream $_test-output-buffered-file->buffer) + 8077 (clear-stream _test-error-stream) + 8078 (clear-stream $_test-error-buffered-file->buffer) + 8079 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8080 68/push 0/imm32 + 8081 68/push 0/imm32 + 8082 89/<- %edx 4/r32/esp + 8083 (tailor-exit-descriptor %edx 0x10) + 8084 # + 8085 (write _test-input-stream "fn foo {\n") + 8086 (write _test-input-stream " var x: (handle int)\n") + 8087 (write _test-input-stream " var y: int\n") + 8088 (write _test-input-stream " copy-to y, x\n") + 8089 (write _test-input-stream "}\n") + 8090 # convert + 8091 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8092 # registers except esp clobbered at this point + 8093 # restore ed + 8094 89/<- %edx 4/r32/esp + 8095 (flush _test-output-buffered-file) + 8096 (flush _test-error-buffered-file) + 8097 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8103 # check output + 8104 (check-stream-equal _test-output-stream "" "F - test-copy-to-non-scalar: output should be empty") + 8105 #? (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: 'x' is too large to copy" "F - test-copy-to-non-scalar: error message") + 8106 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-to: source (second inout) is in memory" "F - test-copy-to-non-scalar: error message") + 8107 # check that stop(1) was called + 8108 (check-ints-equal *(edx+4) 2 "F - test-copy-to-non-scalar: exit status") + 8109 # don't restore from ebp + 8110 81 0/subop/add %esp 8/imm32 + 8111 # . epilogue + 8112 5d/pop-to-ebp + 8113 c3/return + 8114 + 8115 test-compare-with-no-inout: + 8116 # . prologue + 8117 55/push-ebp + 8118 89/<- %ebp 4/r32/esp + 8119 # setup + 8120 (clear-stream _test-input-stream) + 8121 (clear-stream $_test-input-buffered-file->buffer) + 8122 (clear-stream _test-output-stream) + 8123 (clear-stream $_test-output-buffered-file->buffer) + 8124 (clear-stream _test-error-stream) + 8125 (clear-stream $_test-error-buffered-file->buffer) + 8126 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8127 68/push 0/imm32 + 8128 68/push 0/imm32 + 8129 89/<- %edx 4/r32/esp + 8130 (tailor-exit-descriptor %edx 0x10) + 8131 # + 8132 (write _test-input-stream "fn foo {\n") + 8133 (write _test-input-stream " var x: boolean\n") + 8134 (write _test-input-stream " compare\n") + 8135 (write _test-input-stream "}\n") + 8136 # convert + 8137 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8138 # registers except esp clobbered at this point + 8139 # restore ed + 8140 89/<- %edx 4/r32/esp + 8141 (flush _test-output-buffered-file) + 8142 (flush _test-error-buffered-file) + 8143 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8149 # check output + 8150 (check-stream-equal _test-output-stream "" "F - test-compare-with-no-inout: output should be empty") + 8151 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must have two inouts" "F - test-compare-with-no-inout: error message") + 8152 # check that stop(1) was called + 8153 (check-ints-equal *(edx+4) 2 "F - test-compare-with-no-inout: exit status") + 8154 # don't restore from ebp + 8155 81 0/subop/add %esp 8/imm32 + 8156 # . epilogue + 8157 5d/pop-to-ebp + 8158 c3/return + 8159 + 8160 test-compare-with-no-input: + 8161 # . prologue + 8162 55/push-ebp + 8163 89/<- %ebp 4/r32/esp + 8164 # setup + 8165 (clear-stream _test-input-stream) + 8166 (clear-stream $_test-input-buffered-file->buffer) + 8167 (clear-stream _test-output-stream) + 8168 (clear-stream $_test-output-buffered-file->buffer) + 8169 (clear-stream _test-error-stream) + 8170 (clear-stream $_test-error-buffered-file->buffer) + 8171 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8172 68/push 0/imm32 + 8173 68/push 0/imm32 + 8174 89/<- %edx 4/r32/esp + 8175 (tailor-exit-descriptor %edx 0x10) + 8176 # + 8177 (write _test-input-stream "fn foo {\n") + 8178 (write _test-input-stream " var x: boolean\n") + 8179 (write _test-input-stream " compare x\n") + 8180 (write _test-input-stream "}\n") + 8181 # convert + 8182 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8183 # registers except esp clobbered at this point + 8184 # restore ed + 8185 89/<- %edx 4/r32/esp + 8186 (flush _test-output-buffered-file) + 8187 (flush _test-error-buffered-file) + 8188 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8194 # check output + 8195 (check-stream-equal _test-output-stream "" "F - test-compare-with-no-input: output should be empty") + 8196 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must have two inouts" "F - test-compare-with-no-input: error message") + 8197 # check that stop(1) was called + 8198 (check-ints-equal *(edx+4) 2 "F - test-compare-with-no-input: exit status") + 8199 # don't restore from ebp + 8200 81 0/subop/add %esp 8/imm32 + 8201 # . epilogue + 8202 5d/pop-to-ebp + 8203 c3/return + 8204 + 8205 test-compare-with-too-many-inouts: + 8206 # . prologue + 8207 55/push-ebp + 8208 89/<- %ebp 4/r32/esp + 8209 # setup + 8210 (clear-stream _test-input-stream) + 8211 (clear-stream $_test-input-buffered-file->buffer) + 8212 (clear-stream _test-output-stream) + 8213 (clear-stream $_test-output-buffered-file->buffer) + 8214 (clear-stream _test-error-stream) + 8215 (clear-stream $_test-error-buffered-file->buffer) + 8216 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8217 68/push 0/imm32 + 8218 68/push 0/imm32 + 8219 89/<- %edx 4/r32/esp + 8220 (tailor-exit-descriptor %edx 0x10) + 8221 # + 8222 (write _test-input-stream "fn foo {\n") + 8223 (write _test-input-stream " var x: boolean\n") + 8224 (write _test-input-stream " compare x, 0, 0\n") + 8225 (write _test-input-stream "}\n") + 8226 # convert + 8227 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8228 # registers except esp clobbered at this point + 8229 # restore ed + 8230 89/<- %edx 4/r32/esp + 8231 (flush _test-output-buffered-file) + 8232 (flush _test-error-buffered-file) + 8233 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8239 # check output + 8240 (check-stream-equal _test-output-stream "" "F - test-compare-with-too-many-inouts: output should be empty") + 8241 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must have two inouts" "F - test-compare-with-too-many-inouts: error message") + 8242 # check that stop(1) was called + 8243 (check-ints-equal *(edx+4) 2 "F - test-compare-with-too-many-inouts: exit status") + 8244 # don't restore from ebp + 8245 81 0/subop/add %esp 8/imm32 + 8246 # . epilogue + 8247 5d/pop-to-ebp + 8248 c3/return + 8249 + 8250 test-compare-with-output: + 8251 # . prologue + 8252 55/push-ebp + 8253 89/<- %ebp 4/r32/esp + 8254 # setup + 8255 (clear-stream _test-input-stream) + 8256 (clear-stream $_test-input-buffered-file->buffer) + 8257 (clear-stream _test-output-stream) + 8258 (clear-stream $_test-output-buffered-file->buffer) + 8259 (clear-stream _test-error-stream) + 8260 (clear-stream $_test-error-buffered-file->buffer) + 8261 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8262 68/push 0/imm32 + 8263 68/push 0/imm32 + 8264 89/<- %edx 4/r32/esp + 8265 (tailor-exit-descriptor %edx 0x10) + 8266 # + 8267 (write _test-input-stream "fn foo {\n") + 8268 (write _test-input-stream " var x/eax: boolean <- copy 0\n") + 8269 (write _test-input-stream " var y/ecx: boolean <- copy 0\n") + 8270 (write _test-input-stream " x <- compare y, 0\n") + 8271 (write _test-input-stream "}\n") + 8272 # convert + 8273 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8274 # registers except esp clobbered at this point + 8275 # restore ed + 8276 89/<- %edx 4/r32/esp + 8277 (flush _test-output-buffered-file) + 8278 (flush _test-error-buffered-file) + 8279 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8285 # check output + 8286 (check-stream-equal _test-output-stream "" "F - test-compare-with-output: output should be empty") + 8287 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'compare' must not have any outputs" "F - test-compare-with-output: error message") + 8288 # check that stop(1) was called + 8289 (check-ints-equal *(edx+4) 2 "F - test-compare-with-output: exit status") + 8290 # don't restore from ebp + 8291 81 0/subop/add %esp 8/imm32 + 8292 # . epilogue + 8293 5d/pop-to-ebp + 8294 c3/return + 8295 + 8296 test-compare-invalid-value-to-address: + 8297 # . prologue + 8298 55/push-ebp + 8299 89/<- %ebp 4/r32/esp + 8300 # setup + 8301 (clear-stream _test-input-stream) + 8302 (clear-stream $_test-input-buffered-file->buffer) + 8303 (clear-stream _test-output-stream) + 8304 (clear-stream $_test-output-buffered-file->buffer) + 8305 (clear-stream _test-error-stream) + 8306 (clear-stream $_test-error-buffered-file->buffer) + 8307 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8308 68/push 0/imm32 + 8309 68/push 0/imm32 + 8310 89/<- %edx 4/r32/esp + 8311 (tailor-exit-descriptor %edx 0x10) + 8312 # + 8313 (write _test-input-stream "fn foo {\n") + 8314 (write _test-input-stream " var x/eax: int <- copy 0\n") + 8315 (write _test-input-stream " var y: (addr int)\n") + 8316 (write _test-input-stream " compare y, x\n") + 8317 (write _test-input-stream "}\n") + 8318 # convert + 8319 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8320 # registers except esp clobbered at this point + 8321 # restore ed + 8322 89/<- %edx 4/r32/esp + 8323 (flush _test-output-buffered-file) + 8324 (flush _test-error-buffered-file) + 8325 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8331 # check output + 8332 (check-stream-equal _test-output-stream "" "F - test-compare-invalid-value-to-address: output should be empty") + 8333 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: 'y' must be a non-addr non-offset scalar" "F - test-compare-invalid-value-to-address: error message") + 8334 # check that stop(1) was called + 8335 (check-ints-equal *(edx+4) 2 "F - test-compare-invalid-value-to-address: exit status") + 8336 # don't restore from ebp + 8337 81 0/subop/add %esp 8/imm32 + 8338 # . epilogue + 8339 5d/pop-to-ebp + 8340 c3/return + 8341 + 8342 test-compare-address: + 8343 # . prologue + 8344 55/push-ebp + 8345 89/<- %ebp 4/r32/esp + 8346 # setup + 8347 (clear-stream _test-input-stream) + 8348 (clear-stream $_test-input-buffered-file->buffer) + 8349 (clear-stream _test-output-stream) + 8350 (clear-stream $_test-output-buffered-file->buffer) + 8351 # + 8352 (write _test-input-stream "fn foo {\n") + 8353 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") + 8354 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") + 8355 (write _test-input-stream " compare y, x\n") + 8356 (write _test-input-stream "}\n") + 8357 # convert + 8358 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 8359 (flush _test-output-buffered-file) + 8360 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8366 # not bothering checking output + 8367 (check-next-stream-line-equal _test-error-stream "" "F - test-compare-address: error message") + 8368 # . epilogue + 8369 5d/pop-to-ebp + 8370 c3/return + 8371 + 8372 test-compare-deref-address: + 8373 # . prologue + 8374 55/push-ebp + 8375 89/<- %ebp 4/r32/esp + 8376 # setup + 8377 (clear-stream _test-input-stream) + 8378 (clear-stream $_test-input-buffered-file->buffer) + 8379 (clear-stream _test-output-stream) + 8380 (clear-stream $_test-output-buffered-file->buffer) + 8381 # + 8382 (write _test-input-stream "fn foo {\n") + 8383 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") + 8384 (write _test-input-stream " var y/ecx: (addr addr int) <- copy 0\n") + 8385 (write _test-input-stream " compare *y, x\n") + 8386 (write _test-input-stream "}\n") + 8387 # convert + 8388 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 8389 (flush _test-output-buffered-file) + 8390 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8396 # not bothering checking output + 8397 (check-next-stream-line-equal _test-error-stream "" "F - test-compare-deref-address: error message") + 8398 # . epilogue + 8399 5d/pop-to-ebp + 8400 c3/return + 8401 + 8402 test-compare-two-vars-in-memory: + 8403 # . prologue + 8404 55/push-ebp + 8405 89/<- %ebp 4/r32/esp + 8406 # setup + 8407 (clear-stream _test-input-stream) + 8408 (clear-stream $_test-input-buffered-file->buffer) + 8409 (clear-stream _test-output-stream) + 8410 (clear-stream $_test-output-buffered-file->buffer) + 8411 (clear-stream _test-error-stream) + 8412 (clear-stream $_test-error-buffered-file->buffer) + 8413 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8414 68/push 0/imm32 + 8415 68/push 0/imm32 + 8416 89/<- %edx 4/r32/esp + 8417 (tailor-exit-descriptor %edx 0x10) + 8418 # + 8419 (write _test-input-stream "fn foo {\n") + 8420 (write _test-input-stream " var x: boolean\n") + 8421 (write _test-input-stream " compare x, x\n") + 8422 (write _test-input-stream "}\n") + 8423 # convert + 8424 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8425 # registers except esp clobbered at this point + 8426 # restore ed + 8427 89/<- %edx 4/r32/esp + 8428 (flush _test-output-buffered-file) + 8429 (flush _test-error-buffered-file) + 8430 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8436 # check output + 8437 (check-stream-equal _test-output-stream "" "F - test-compare-two-vars-in-memory: output should be empty") + 8438 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: both inouts are in memory" "F - test-compare-two-vars-in-memory: error message") + 8439 # check that stop(1) was called + 8440 (check-ints-equal *(edx+4) 2 "F - test-compare-two-vars-in-memory: exit status") + 8441 # don't restore from ebp + 8442 81 0/subop/add %esp 8/imm32 + 8443 # . epilogue + 8444 5d/pop-to-ebp + 8445 c3/return + 8446 + 8447 test-compare-non-scalar: + 8448 # . prologue + 8449 55/push-ebp + 8450 89/<- %ebp 4/r32/esp + 8451 # setup + 8452 (clear-stream _test-input-stream) + 8453 (clear-stream $_test-input-buffered-file->buffer) + 8454 (clear-stream _test-output-stream) + 8455 (clear-stream $_test-output-buffered-file->buffer) + 8456 (clear-stream _test-error-stream) + 8457 (clear-stream $_test-error-buffered-file->buffer) + 8458 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8459 68/push 0/imm32 + 8460 68/push 0/imm32 + 8461 89/<- %edx 4/r32/esp + 8462 (tailor-exit-descriptor %edx 0x10) + 8463 # + 8464 (write _test-input-stream "fn foo {\n") + 8465 (write _test-input-stream " var x: (handle int)\n") + 8466 (write _test-input-stream " var y: int\n") + 8467 (write _test-input-stream " compare y, x\n") + 8468 (write _test-input-stream "}\n") + 8469 # convert + 8470 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8471 # registers except esp clobbered at this point + 8472 # restore ed + 8473 89/<- %edx 4/r32/esp + 8474 (flush _test-output-buffered-file) + 8475 (flush _test-error-buffered-file) + 8476 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8482 # check output + 8483 (check-stream-equal _test-output-stream "" "F - test-compare-non-scalar: output should be empty") + 8484 #? (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: 'x' is too large to compare" "F - test-compare-non-scalar: error message") + 8485 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compare: both inouts are in memory" "F - test-compare-non-scalar: error message") + 8486 # check that stop(1) was called + 8487 (check-ints-equal *(edx+4) 2 "F - test-compare-non-scalar: exit status") + 8488 # don't restore from ebp + 8489 81 0/subop/add %esp 8/imm32 + 8490 # . epilogue + 8491 5d/pop-to-ebp + 8492 c3/return + 8493 + 8494 test-address-with-no-inout: + 8495 # . prologue + 8496 55/push-ebp + 8497 89/<- %ebp 4/r32/esp + 8498 # setup + 8499 (clear-stream _test-input-stream) + 8500 (clear-stream $_test-input-buffered-file->buffer) + 8501 (clear-stream _test-output-stream) + 8502 (clear-stream $_test-output-buffered-file->buffer) + 8503 (clear-stream _test-error-stream) + 8504 (clear-stream $_test-error-buffered-file->buffer) + 8505 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8506 68/push 0/imm32 + 8507 68/push 0/imm32 + 8508 89/<- %edx 4/r32/esp + 8509 (tailor-exit-descriptor %edx 0x10) + 8510 # + 8511 (write _test-input-stream "fn foo {\n") + 8512 (write _test-input-stream " var x/eax: boolean <- address\n") + 8513 (write _test-input-stream "}\n") + 8514 # convert + 8515 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8516 # registers except esp clobbered at this point + 8517 # restore ed + 8518 89/<- %edx 4/r32/esp + 8519 (flush _test-output-buffered-file) + 8520 (flush _test-error-buffered-file) + 8521 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8527 # check output + 8528 (check-stream-equal _test-output-stream "" "F - test-address-with-no-inout: output should be empty") + 8529 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' expects an inout" "F - test-address-with-no-inout: error message") + 8530 # check that stop(1) was called + 8531 (check-ints-equal *(edx+4) 2 "F - test-address-with-no-inout: exit status") + 8532 # don't restore from ebp + 8533 81 0/subop/add %esp 8/imm32 + 8534 # . epilogue + 8535 5d/pop-to-ebp + 8536 c3/return + 8537 + 8538 test-address-with-multiple-inouts: + 8539 # . prologue + 8540 55/push-ebp + 8541 89/<- %ebp 4/r32/esp + 8542 # setup + 8543 (clear-stream _test-input-stream) + 8544 (clear-stream $_test-input-buffered-file->buffer) + 8545 (clear-stream _test-output-stream) + 8546 (clear-stream $_test-output-buffered-file->buffer) + 8547 (clear-stream _test-error-stream) + 8548 (clear-stream $_test-error-buffered-file->buffer) + 8549 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8550 68/push 0/imm32 + 8551 68/push 0/imm32 + 8552 89/<- %edx 4/r32/esp + 8553 (tailor-exit-descriptor %edx 0x10) + 8554 # + 8555 (write _test-input-stream "fn foo {\n") + 8556 (write _test-input-stream " var x/eax: boolean <- address 0, 0\n") + 8557 (write _test-input-stream "}\n") + 8558 # convert + 8559 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8560 # registers except esp clobbered at this point + 8561 # restore ed + 8562 89/<- %edx 4/r32/esp + 8563 (flush _test-output-buffered-file) + 8564 (flush _test-error-buffered-file) + 8565 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8571 # check output + 8572 (check-stream-equal _test-output-stream "" "F - test-address-with-multiple-inouts: output should be empty") + 8573 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' must have just one inout" "F - test-address-with-multiple-inouts: error message") + 8574 # check that stop(1) was called + 8575 (check-ints-equal *(edx+4) 2 "F - test-address-with-multiple-inouts: exit status") + 8576 # don't restore from ebp + 8577 81 0/subop/add %esp 8/imm32 + 8578 # . epilogue + 8579 5d/pop-to-ebp + 8580 c3/return + 8581 + 8582 test-address-with-no-output: + 8583 # . prologue + 8584 55/push-ebp + 8585 89/<- %ebp 4/r32/esp + 8586 # setup + 8587 (clear-stream _test-input-stream) + 8588 (clear-stream $_test-input-buffered-file->buffer) + 8589 (clear-stream _test-output-stream) + 8590 (clear-stream $_test-output-buffered-file->buffer) + 8591 (clear-stream _test-error-stream) + 8592 (clear-stream $_test-error-buffered-file->buffer) + 8593 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8594 68/push 0/imm32 + 8595 68/push 0/imm32 + 8596 89/<- %edx 4/r32/esp + 8597 (tailor-exit-descriptor %edx 0x10) + 8598 # + 8599 (write _test-input-stream "fn foo {\n") + 8600 (write _test-input-stream " address 0\n") + 8601 (write _test-input-stream "}\n") + 8602 # convert + 8603 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8604 # registers except esp clobbered at this point + 8605 # restore ed + 8606 89/<- %edx 4/r32/esp + 8607 (flush _test-output-buffered-file) + 8608 (flush _test-error-buffered-file) + 8609 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8615 # check output + 8616 (check-stream-equal _test-output-stream "" "F - test-address-with-no-output: output should be empty") + 8617 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' expects an output" "F - test-address-with-no-output: error message") + 8618 # check that stop(1) was called + 8619 (check-ints-equal *(edx+4) 2 "F - test-address-with-no-output: exit status") + 8620 # don't restore from ebp + 8621 81 0/subop/add %esp 8/imm32 + 8622 # . epilogue + 8623 5d/pop-to-ebp + 8624 c3/return + 8625 + 8626 test-address-with-multiple-outputs: + 8627 # . prologue + 8628 55/push-ebp + 8629 89/<- %ebp 4/r32/esp + 8630 # setup + 8631 (clear-stream _test-input-stream) + 8632 (clear-stream $_test-input-buffered-file->buffer) + 8633 (clear-stream _test-output-stream) + 8634 (clear-stream $_test-output-buffered-file->buffer) + 8635 (clear-stream _test-error-stream) + 8636 (clear-stream $_test-error-buffered-file->buffer) + 8637 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8638 68/push 0/imm32 + 8639 68/push 0/imm32 + 8640 89/<- %edx 4/r32/esp + 8641 (tailor-exit-descriptor %edx 0x10) + 8642 # + 8643 (write _test-input-stream "fn foo {\n") + 8644 (write _test-input-stream " var x/eax: boolean <- copy 0\n") + 8645 (write _test-input-stream " var y/ecx: boolean <- copy 0\n") + 8646 (write _test-input-stream " x, y <- address 0\n") + 8647 (write _test-input-stream "}\n") + 8648 # convert + 8649 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8650 # registers except esp clobbered at this point + 8651 # restore ed + 8652 89/<- %edx 4/r32/esp + 8653 (flush _test-output-buffered-file) + 8654 (flush _test-error-buffered-file) + 8655 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8661 # check output + 8662 (check-stream-equal _test-output-stream "" "F - test-address-with-multiple-outputs: output should be empty") + 8663 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'address' must have just one output" "F - test-address-with-multiple-outputs: error message") + 8664 # check that stop(1) was called + 8665 (check-ints-equal *(edx+4) 2 "F - test-address-with-multiple-outputs: exit status") + 8666 # don't restore from ebp + 8667 81 0/subop/add %esp 8/imm32 + 8668 # . epilogue + 8669 5d/pop-to-ebp + 8670 c3/return + 8671 + 8672 # silly but it works + 8673 test-address-of-deref: + 8674 # . prologue + 8675 55/push-ebp + 8676 89/<- %ebp 4/r32/esp + 8677 # setup + 8678 (clear-stream _test-input-stream) + 8679 (clear-stream $_test-input-buffered-file->buffer) + 8680 (clear-stream _test-output-stream) + 8681 (clear-stream $_test-output-buffered-file->buffer) 8682 # 8683 (write _test-input-stream "fn foo {\n") - 8684 (write _test-input-stream " var a: t\n") - 8685 (write _test-input-stream " var c/ecx: (addr boolean) <- get a, x\n") + 8684 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") + 8685 (write _test-input-stream " var y/ecx: (addr int) <- address *x\n") 8686 (write _test-input-stream "}\n") - 8687 (write _test-input-stream "type t {\n") - 8688 (write _test-input-stream " x: int\n") - 8689 (write _test-input-stream "}\n") - 8690 # convert - 8691 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8692 # registers except esp clobbered at this point - 8693 # restore ed - 8694 89/<- %edx 4/r32/esp - 8695 (flush _test-output-buffered-file) - 8696 (flush _test-error-buffered-file) - 8697 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8703 # check output - 8704 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-4: output should be empty") - 8705 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: wrong output type for member 'x' of type 't'" "F - test-get-with-wrong-output-type-4: error message") - 8706 # check that stop(1) was called - 8707 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-4: exit status") - 8708 # don't restore from ebp - 8709 81 0/subop/add %esp 8/imm32 - 8710 # . epilogue - 8711 5d/pop-to-ebp - 8712 c3/return - 8713 - 8714 test-get-with-wrong-output-type-5: - 8715 # . prologue - 8716 55/push-ebp - 8717 89/<- %ebp 4/r32/esp - 8718 # setup - 8719 (clear-stream _test-input-stream) - 8720 (clear-stream $_test-input-buffered-file->buffer) - 8721 (clear-stream _test-output-stream) - 8722 (clear-stream $_test-output-buffered-file->buffer) - 8723 # - 8724 (write _test-input-stream "fn foo {\n") - 8725 (write _test-input-stream " var a: t\n") - 8726 (write _test-input-stream " var c/ecx: (addr handle int) <- get a, x\n") - 8727 (write _test-input-stream "}\n") - 8728 (write _test-input-stream "type t {\n") - 8729 (write _test-input-stream " x: (handle int)\n") - 8730 (write _test-input-stream "}\n") - 8731 # convert - 8732 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 8733 (flush _test-output-buffered-file) - 8734 # no errors - 8735 # . epilogue - 8736 89/<- %esp 5/r32/ebp - 8737 5d/pop-to-ebp - 8738 c3/return - 8739 - 8740 test-get-with-too-few-inouts: - 8741 # . prologue - 8742 55/push-ebp - 8743 89/<- %ebp 4/r32/esp - 8744 # setup - 8745 (clear-stream _test-input-stream) - 8746 (clear-stream $_test-input-buffered-file->buffer) - 8747 (clear-stream _test-output-stream) - 8748 (clear-stream $_test-output-buffered-file->buffer) - 8749 (clear-stream _test-error-stream) - 8750 (clear-stream $_test-error-buffered-file->buffer) - 8751 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8752 68/push 0/imm32 - 8753 68/push 0/imm32 - 8754 89/<- %edx 4/r32/esp - 8755 (tailor-exit-descriptor %edx 0x10) - 8756 # - 8757 (write _test-input-stream "fn foo {\n") - 8758 (write _test-input-stream " var a: t\n") - 8759 (write _test-input-stream " var c/ecx: (addr int) <- get a\n") - 8760 (write _test-input-stream "}\n") - 8761 (write _test-input-stream "type t {\n") - 8762 (write _test-input-stream " x: int\n") - 8763 (write _test-input-stream "}\n") - 8764 # convert - 8765 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8766 # registers except esp clobbered at this point - 8767 # restore ed - 8768 89/<- %edx 4/r32/esp - 8769 (flush _test-output-buffered-file) - 8770 (flush _test-error-buffered-file) - 8771 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8777 # check output - 8778 (check-stream-equal _test-output-stream "" "F - test-get-with-too-few-inouts: output should be empty") - 8779 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too few inouts (2 required)" "F - test-get-with-too-few-inouts: error message") - 8780 # check that stop(1) was called - 8781 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-few-inouts: exit status") - 8782 # don't restore from ebp - 8783 81 0/subop/add %esp 8/imm32 - 8784 # . epilogue - 8785 5d/pop-to-ebp - 8786 c3/return - 8787 - 8788 test-get-with-too-many-inouts: - 8789 # . prologue - 8790 55/push-ebp - 8791 89/<- %ebp 4/r32/esp - 8792 # setup - 8793 (clear-stream _test-input-stream) - 8794 (clear-stream $_test-input-buffered-file->buffer) - 8795 (clear-stream _test-output-stream) - 8796 (clear-stream $_test-output-buffered-file->buffer) - 8797 (clear-stream _test-error-stream) - 8798 (clear-stream $_test-error-buffered-file->buffer) - 8799 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8800 68/push 0/imm32 - 8801 68/push 0/imm32 - 8802 89/<- %edx 4/r32/esp - 8803 (tailor-exit-descriptor %edx 0x10) - 8804 # - 8805 (write _test-input-stream "fn foo {\n") - 8806 (write _test-input-stream " var a: t\n") - 8807 (write _test-input-stream " var c/ecx: (addr int) <- get a, x, 0\n") - 8808 (write _test-input-stream "}\n") - 8809 (write _test-input-stream "type t {\n") - 8810 (write _test-input-stream " x: int\n") - 8811 (write _test-input-stream "}\n") - 8812 # convert - 8813 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8814 # registers except esp clobbered at this point - 8815 # restore ed - 8816 89/<- %edx 4/r32/esp - 8817 (flush _test-output-buffered-file) - 8818 (flush _test-error-buffered-file) - 8819 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8825 # check output - 8826 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-inouts: output should be empty") - 8827 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many inouts (2 required)" "F - test-get-with-too-many-inouts: error message") - 8828 # check that stop(1) was called - 8829 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-inouts: exit status") - 8830 # don't restore from ebp - 8831 81 0/subop/add %esp 8/imm32 - 8832 # . epilogue - 8833 5d/pop-to-ebp - 8834 c3/return - 8835 - 8836 test-get-with-no-output: - 8837 # . prologue - 8838 55/push-ebp - 8839 89/<- %ebp 4/r32/esp - 8840 # setup - 8841 (clear-stream _test-input-stream) - 8842 (clear-stream $_test-input-buffered-file->buffer) - 8843 (clear-stream _test-output-stream) - 8844 (clear-stream $_test-output-buffered-file->buffer) - 8845 (clear-stream _test-error-stream) - 8846 (clear-stream $_test-error-buffered-file->buffer) - 8847 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8848 68/push 0/imm32 - 8849 68/push 0/imm32 - 8850 89/<- %edx 4/r32/esp - 8851 (tailor-exit-descriptor %edx 0x10) - 8852 # - 8853 (write _test-input-stream "fn foo {\n") - 8854 (write _test-input-stream " var a: t\n") - 8855 (write _test-input-stream " get a, x\n") - 8856 (write _test-input-stream "}\n") - 8857 (write _test-input-stream "type t {\n") - 8858 (write _test-input-stream " x: int\n") - 8859 (write _test-input-stream "}\n") - 8860 # convert - 8861 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8862 # registers except esp clobbered at this point - 8863 # restore ed - 8864 89/<- %edx 4/r32/esp - 8865 (flush _test-output-buffered-file) - 8866 (flush _test-error-buffered-file) - 8867 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8873 # check output - 8874 (check-stream-equal _test-output-stream "" "F - test-get-with-no-output: output should be empty") - 8875 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: must have an output" "F - test-get-with-no-output: error message") - 8876 # check that stop(1) was called - 8877 (check-ints-equal *(edx+4) 2 "F - test-get-with-no-output: exit status") - 8878 # don't restore from ebp - 8879 81 0/subop/add %esp 8/imm32 - 8880 # . epilogue - 8881 5d/pop-to-ebp - 8882 c3/return - 8883 - 8884 test-get-with-too-many-outputs: - 8885 # . prologue - 8886 55/push-ebp - 8887 89/<- %ebp 4/r32/esp - 8888 # setup - 8889 (clear-stream _test-input-stream) - 8890 (clear-stream $_test-input-buffered-file->buffer) - 8891 (clear-stream _test-output-stream) - 8892 (clear-stream $_test-output-buffered-file->buffer) - 8893 (clear-stream _test-error-stream) - 8894 (clear-stream $_test-error-buffered-file->buffer) - 8895 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 8896 68/push 0/imm32 - 8897 68/push 0/imm32 - 8898 89/<- %edx 4/r32/esp - 8899 (tailor-exit-descriptor %edx 0x10) - 8900 # - 8901 (write _test-input-stream "fn foo {\n") - 8902 (write _test-input-stream " var a: t\n") - 8903 (write _test-input-stream " var b: int\n") - 8904 (write _test-input-stream " var c/eax: (addr int) <- copy 0\n") - 8905 (write _test-input-stream " c, b <- get a, x\n") - 8906 (write _test-input-stream "}\n") - 8907 (write _test-input-stream "type t {\n") - 8908 (write _test-input-stream " x: int\n") - 8909 (write _test-input-stream "}\n") - 8910 # convert - 8911 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 8912 # registers except esp clobbered at this point - 8913 # restore ed - 8914 89/<- %edx 4/r32/esp - 8915 (flush _test-output-buffered-file) - 8916 (flush _test-error-buffered-file) - 8917 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8923 # check output - 8924 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-outputs: output should be empty") - 8925 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many outputs (1 required)" "F - test-get-with-too-many-outputs: error message") - 8926 # check that stop(1) was called - 8927 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-outputs: exit status") - 8928 # don't restore from ebp - 8929 81 0/subop/add %esp 8/imm32 - 8930 # . epilogue - 8931 5d/pop-to-ebp - 8932 c3/return - 8933 - 8934 test-convert-array-of-user-defined-types: - 8935 # . prologue - 8936 55/push-ebp - 8937 89/<- %ebp 4/r32/esp - 8938 # setup - 8939 (clear-stream _test-input-stream) - 8940 (clear-stream $_test-input-buffered-file->buffer) - 8941 (clear-stream _test-output-stream) - 8942 (clear-stream $_test-output-buffered-file->buffer) - 8943 # - 8944 (write _test-input-stream "type t {\n") # each t is 8 bytes, which is a power of 2 - 8945 (write _test-input-stream " x: int\n") - 8946 (write _test-input-stream " y: int\n") - 8947 (write _test-input-stream "}\n") - 8948 (write _test-input-stream "fn foo {\n") - 8949 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 8950 (write _test-input-stream " var idx/ecx: int <- copy 3\n") - 8951 (write _test-input-stream " var x/eax: (addr t) <- index arr, idx\n") - 8952 (write _test-input-stream "}\n") - 8953 # convert - 8954 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 8955 (flush _test-output-buffered-file) - 8956 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 8962 # check output - 8963 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-array-of-user-defined-types/0") - 8964 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-array-of-user-defined-types/1") - 8965 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-array-of-user-defined-types/2") - 8966 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-array-of-user-defined-types/3") - 8967 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-array-of-user-defined-types/4") - 8968 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-array-of-user-defined-types/5") - 8969 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-array-of-user-defined-types/6") - 8970 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-array-of-user-defined-types/7") - 8971 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-array-of-user-defined-types/8") - 8972 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-array-of-user-defined-types/9") - 8973 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000003 + 4) 0x00000000/r32" "F - test-convert-array-of-user-defined-types/11") - 8974 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-array-of-user-defined-types/13") - 8975 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-array-of-user-defined-types/14") - 8976 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-array-of-user-defined-types/15") - 8977 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-array-of-user-defined-types/16") - 8978 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-array-of-user-defined-types/17") - 8979 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-array-of-user-defined-types/18") - 8980 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-array-of-user-defined-types/19") - 8981 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-array-of-user-defined-types/20") - 8982 # . epilogue - 8983 89/<- %esp 5/r32/ebp - 8984 5d/pop-to-ebp - 8985 c3/return - 8986 - 8987 test-convert-length-of-array-of-user-defined-types-to-eax: - 8988 # . prologue - 8989 55/push-ebp - 8990 89/<- %ebp 4/r32/esp - 8991 # setup - 8992 (clear-stream _test-input-stream) - 8993 (clear-stream $_test-input-buffered-file->buffer) - 8994 (clear-stream _test-output-stream) - 8995 (clear-stream $_test-output-buffered-file->buffer) - 8996 # - 8997 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 - 8998 (write _test-input-stream " x: int\n") - 8999 (write _test-input-stream " y: int\n") - 9000 (write _test-input-stream " z: int\n") - 9001 (write _test-input-stream "}\n") - 9002 (write _test-input-stream "fn foo {\n") - 9003 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 9004 (write _test-input-stream " var x/eax: int <- length arr\n") - 9005 (write _test-input-stream "}\n") - 9006 # convert - 9007 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 9008 (flush _test-output-buffered-file) - 9009 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9015 # check output - 9016 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/0") - 9017 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/1") - 9018 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/2") - 9019 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/3") - 9020 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-eax/4") - 9021 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/5") - 9022 # var arr - 9023 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/6") - 9024 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/7") - 9025 # length instruction - 9026 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/8") - 9027 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/9") - 9028 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/10") - 9029 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/11") - 9030 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/12") - 9031 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/13") - 9032 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/14") - 9033 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/15") - 9034 # reclaim arr - 9035 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/16") - 9036 # - 9037 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-eax/17") - 9038 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/18") - 9039 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/19") - 9040 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/20") - 9041 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/21") - 9042 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-eax/22") - 9043 # . epilogue - 9044 89/<- %esp 5/r32/ebp - 9045 5d/pop-to-ebp - 9046 c3/return - 9047 - 9048 test-convert-length-of-array-of-user-defined-types-to-ecx: - 9049 # . prologue - 9050 55/push-ebp - 9051 89/<- %ebp 4/r32/esp - 9052 # setup - 9053 (clear-stream _test-input-stream) - 9054 (clear-stream $_test-input-buffered-file->buffer) - 9055 (clear-stream _test-output-stream) - 9056 (clear-stream $_test-output-buffered-file->buffer) - 9057 # - 9058 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 - 9059 (write _test-input-stream " x: int\n") - 9060 (write _test-input-stream " y: int\n") - 9061 (write _test-input-stream " z: int\n") - 9062 (write _test-input-stream "}\n") - 9063 (write _test-input-stream "fn foo {\n") - 9064 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 9065 (write _test-input-stream " var x/ecx: int <- length arr\n") - 9066 (write _test-input-stream "}\n") - 9067 # convert - 9068 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 9069 (flush _test-output-buffered-file) - 9070 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9076 # check output - 9077 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/0") - 9078 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/1") - 9079 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/2") - 9080 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/3") - 9081 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/4") - 9082 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/5") - 9083 # var a - 9084 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/6") - 9085 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/7") - 9086 # var x - 9087 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/8") - 9088 # length instruction - 9089 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/9") - 9090 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/10") - 9091 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/11") - 9092 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/12") - 9093 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/13") - 9094 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/14") - 9095 (check-next-stream-line-equal _test-output-stream " 89/<- %ecx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/15") - 9096 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/16") - 9097 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/17") - 9098 # reclaim x - 9099 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/18") - 9100 # reclaim a - 9101 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/19") - 9102 # - 9103 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/20") - 9104 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/21") - 9105 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/22") - 9106 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/23") - 9107 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/24") - 9108 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/25") - 9109 # . epilogue - 9110 89/<- %esp 5/r32/ebp - 9111 5d/pop-to-ebp - 9112 c3/return - 9113 - 9114 test-convert-length-of-array-of-user-defined-types-to-edx: - 9115 # . prologue - 9116 55/push-ebp - 9117 89/<- %ebp 4/r32/esp - 9118 # setup - 9119 (clear-stream _test-input-stream) - 9120 (clear-stream $_test-input-buffered-file->buffer) - 9121 (clear-stream _test-output-stream) - 9122 (clear-stream $_test-output-buffered-file->buffer) - 9123 # - 9124 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 - 9125 (write _test-input-stream " x: int\n") - 9126 (write _test-input-stream " y: int\n") - 9127 (write _test-input-stream " z: int\n") - 9128 (write _test-input-stream "}\n") - 9129 (write _test-input-stream "fn foo {\n") - 9130 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 9131 (write _test-input-stream " var x/edx: int <- length arr\n") - 9132 (write _test-input-stream "}\n") - 9133 # convert - 9134 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 9135 (flush _test-output-buffered-file) - 9136 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9142 # check output - 9143 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/0") - 9144 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/1") - 9145 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/2") - 9146 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/3") - 9147 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-edx/4") - 9148 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/5") - 9149 # var a - 9150 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/6") - 9151 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/7") - 9152 # var x - 9153 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/8") - 9154 # length instruction - 9155 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/9") - 9156 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/10") - 9157 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/11") - 9158 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/12") - 9159 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/13") - 9160 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/14") - 9161 (check-next-stream-line-equal _test-output-stream " 89/<- %edx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/15") - 9162 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/16") - 9163 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/17") - 9164 # reclaim x - 9165 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/18") - 9166 # reclaim a - 9167 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/19") - 9168 # - 9169 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-edx/20") - 9170 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/21") - 9171 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/22") - 9172 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/23") - 9173 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/24") - 9174 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-edx/25") - 9175 # . epilogue - 9176 89/<- %esp 5/r32/ebp - 9177 5d/pop-to-ebp - 9178 c3/return - 9179 - 9180 test-convert-length-of-array-of-user-defined-types: - 9181 # . prologue - 9182 55/push-ebp - 9183 89/<- %ebp 4/r32/esp - 9184 # setup - 9185 (clear-stream _test-input-stream) - 9186 (clear-stream $_test-input-buffered-file->buffer) - 9187 (clear-stream _test-output-stream) - 9188 (clear-stream $_test-output-buffered-file->buffer) - 9189 # - 9190 (write _test-input-stream "type t {\n") # each t is 8 bytes, which is a power of 2 - 9191 (write _test-input-stream " x: int\n") - 9192 (write _test-input-stream " y: int\n") - 9193 (write _test-input-stream " z: int\n") - 9194 (write _test-input-stream "}\n") - 9195 (write _test-input-stream "fn foo {\n") - 9196 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") - 9197 (write _test-input-stream " var x/ebx: int <- length arr\n") - 9198 (write _test-input-stream "}\n") - 9199 # convert - 9200 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) - 9201 (flush _test-output-buffered-file) - 9202 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9208 # check output - 9209 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types/0") - 9210 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types/1") - 9211 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types/2") - 9212 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types/3") - 9213 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types/4") - 9214 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types/5") - 9215 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types/6") - 9216 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types/7") - 9217 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-length-of-array-of-user-defined-types/8") - 9218 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types/9") - 9219 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types/10") - 9220 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types/11") - 9221 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types/12") - 9222 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types/13") - 9223 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types/14") - 9224 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types/15") - 9225 (check-next-stream-line-equal _test-output-stream " 89/<- %ebx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types/16") - 9226 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types/17") - 9227 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types/18") - 9228 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types/19") - 9229 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ebx" "F - test-convert-length-of-array-of-user-defined-types/20") - 9230 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types/21") - 9231 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types/22") - 9232 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types/23") - 9233 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types/24") - 9234 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types/25") - 9235 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types/26") - 9236 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types/27") - 9237 # . epilogue - 9238 89/<- %esp 5/r32/ebp - 9239 5d/pop-to-ebp - 9240 c3/return - 9241 - 9242 test-index-with-non-array-atom-base-type: - 9243 # . prologue - 9244 55/push-ebp - 9245 89/<- %ebp 4/r32/esp - 9246 # setup - 9247 (clear-stream _test-input-stream) - 9248 (clear-stream $_test-input-buffered-file->buffer) - 9249 (clear-stream _test-output-stream) - 9250 (clear-stream $_test-output-buffered-file->buffer) - 9251 (clear-stream _test-error-stream) - 9252 (clear-stream $_test-error-buffered-file->buffer) - 9253 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9254 68/push 0/imm32 - 9255 68/push 0/imm32 - 9256 89/<- %edx 4/r32/esp - 9257 (tailor-exit-descriptor %edx 0x10) - 9258 # - 9259 (write _test-input-stream "fn foo {\n") - 9260 (write _test-input-stream " var a: int\n") - 9261 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") - 9262 (write _test-input-stream "}\n") - 9263 # convert - 9264 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9265 # registers except esp clobbered at this point - 9266 # restore ed - 9267 89/<- %edx 4/r32/esp - 9268 (flush _test-output-buffered-file) - 9269 (flush _test-error-buffered-file) - 9270 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9276 # check output - 9277 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-atom-base-type: output should be empty") - 9278 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-atom-base-type: error message") - 9279 # check that stop(1) was called - 9280 (check-ints-equal *(edx+4) 2 "F - test-index-with-non-array-atom-base-type: exit status") - 9281 # don't restore from ebp - 9282 81 0/subop/add %esp 8/imm32 - 9283 # . epilogue - 9284 5d/pop-to-ebp - 9285 c3/return - 9286 - 9287 test-index-with-non-array-compound-base-type: - 9288 # . prologue - 9289 55/push-ebp - 9290 89/<- %ebp 4/r32/esp - 9291 # setup - 9292 (clear-stream _test-input-stream) - 9293 (clear-stream $_test-input-buffered-file->buffer) - 9294 (clear-stream _test-output-stream) - 9295 (clear-stream $_test-output-buffered-file->buffer) - 9296 (clear-stream _test-error-stream) - 9297 (clear-stream $_test-error-buffered-file->buffer) - 9298 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9299 68/push 0/imm32 - 9300 68/push 0/imm32 - 9301 89/<- %edx 4/r32/esp - 9302 (tailor-exit-descriptor %edx 0x10) - 9303 # - 9304 (write _test-input-stream "fn foo {\n") - 9305 (write _test-input-stream " var a: (handle int)\n") - 9306 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") - 9307 (write _test-input-stream "}\n") - 9308 # convert - 9309 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9310 # registers except esp clobbered at this point - 9311 # restore ed - 9312 89/<- %edx 4/r32/esp - 9313 (flush _test-output-buffered-file) - 9314 (flush _test-error-buffered-file) - 9315 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9321 # check output - 9322 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-compound-base-type: output should be empty") - 9323 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-compound-base-type: error message") - 9324 # check that stop(1) was called - 9325 (check-ints-equal *(edx+4) 2 "F - test-index-with-non-array-compound-base-type: exit status") - 9326 # don't restore from ebp - 9327 81 0/subop/add %esp 8/imm32 - 9328 # . epilogue - 9329 5d/pop-to-ebp - 9330 c3/return - 9331 - 9332 test-index-with-non-array-compound-base-type-2: - 9333 # . prologue - 9334 55/push-ebp - 9335 89/<- %ebp 4/r32/esp - 9336 # setup - 9337 (clear-stream _test-input-stream) - 9338 (clear-stream $_test-input-buffered-file->buffer) - 9339 (clear-stream _test-output-stream) - 9340 (clear-stream $_test-output-buffered-file->buffer) - 9341 (clear-stream _test-error-stream) - 9342 (clear-stream $_test-error-buffered-file->buffer) - 9343 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9344 68/push 0/imm32 - 9345 68/push 0/imm32 - 9346 89/<- %edx 4/r32/esp - 9347 (tailor-exit-descriptor %edx 0x10) - 9348 # - 9349 (write _test-input-stream "fn foo {\n") - 9350 (write _test-input-stream " var a: (addr int)\n") - 9351 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") - 9352 (write _test-input-stream "}\n") - 9353 # convert - 9354 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9355 # registers except esp clobbered at this point - 9356 # restore ed - 9357 89/<- %edx 4/r32/esp - 9358 (flush _test-output-buffered-file) - 9359 (flush _test-error-buffered-file) - 9360 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9366 # check output - 9367 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-compound-base-type-2: output should be empty") - 9368 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-compound-base-type-2: error message") - 9369 # check that stop(1) was called - 9370 (check-ints-equal *(edx+4) 2 "F - test-index-with-non-array-compound-base-type-2: exit status") - 9371 # don't restore from ebp - 9372 81 0/subop/add %esp 8/imm32 - 9373 # . epilogue - 9374 5d/pop-to-ebp - 9375 c3/return - 9376 - 9377 test-index-with-array-atom-base-type: - 9378 # . prologue - 9379 55/push-ebp - 9380 89/<- %ebp 4/r32/esp - 9381 # setup - 9382 (clear-stream _test-input-stream) - 9383 (clear-stream $_test-input-buffered-file->buffer) - 9384 (clear-stream _test-output-stream) - 9385 (clear-stream $_test-output-buffered-file->buffer) - 9386 (clear-stream _test-error-stream) - 9387 (clear-stream $_test-error-buffered-file->buffer) - 9388 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9389 68/push 0/imm32 - 9390 68/push 0/imm32 - 9391 89/<- %edx 4/r32/esp - 9392 (tailor-exit-descriptor %edx 0x10) - 9393 # - 9394 (write _test-input-stream "fn foo {\n") - 9395 (write _test-input-stream " var a: array\n") - 9396 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") - 9397 (write _test-input-stream "}\n") - 9398 # convert - 9399 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9400 # registers except esp clobbered at this point - 9401 # restore ed - 9402 89/<- %edx 4/r32/esp - 9403 (flush _test-output-buffered-file) - 9404 (flush _test-error-buffered-file) - 9405 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9411 # check output - 9412 (check-stream-equal _test-output-stream "" "F - test-index-with-array-atom-base-type: output should be empty") - 9413 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: array 'a' must specify the type of its elements" "F - test-index-with-array-atom-base-type: error message") - 9414 # check that stop(1) was called - 9415 (check-ints-equal *(edx+4) 2 "F - test-index-with-array-atom-base-type: exit status") - 9416 # don't restore from ebp - 9417 81 0/subop/add %esp 8/imm32 - 9418 # . epilogue - 9419 5d/pop-to-ebp - 9420 c3/return - 9421 - 9422 test-index-with-addr-base-on-stack: - 9423 # . prologue - 9424 55/push-ebp - 9425 89/<- %ebp 4/r32/esp - 9426 # setup - 9427 (clear-stream _test-input-stream) - 9428 (clear-stream $_test-input-buffered-file->buffer) - 9429 (clear-stream _test-output-stream) - 9430 (clear-stream $_test-output-buffered-file->buffer) - 9431 (clear-stream _test-error-stream) - 9432 (clear-stream $_test-error-buffered-file->buffer) - 9433 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9434 68/push 0/imm32 - 9435 68/push 0/imm32 - 9436 89/<- %edx 4/r32/esp - 9437 (tailor-exit-descriptor %edx 0x10) - 9438 # - 9439 (write _test-input-stream "fn foo {\n") - 9440 (write _test-input-stream " var a: (addr array int)\n") - 9441 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") - 9442 (write _test-input-stream "}\n") - 9443 # convert - 9444 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9445 # registers except esp clobbered at this point - 9446 # restore ed - 9447 89/<- %edx 4/r32/esp - 9448 (flush _test-output-buffered-file) - 9449 (flush _test-error-buffered-file) - 9450 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9456 # check output - 9457 (check-stream-equal _test-output-stream "" "F - test-index-with-addr-base-on-stack: output should be empty") - 9458 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is an addr to an array, and so must live in a register" "F - test-index-with-addr-base-on-stack: error message") - 9459 # check that stop(1) was called - 9460 (check-ints-equal *(edx+4) 2 "F - test-index-with-addr-base-on-stack: exit status") - 9461 # don't restore from ebp - 9462 81 0/subop/add %esp 8/imm32 - 9463 # . epilogue - 9464 5d/pop-to-ebp - 9465 c3/return - 9466 - 9467 test-index-with-wrong-index-type: - 9468 # . prologue - 9469 55/push-ebp - 9470 89/<- %ebp 4/r32/esp - 9471 # setup - 9472 (clear-stream _test-input-stream) - 9473 (clear-stream $_test-input-buffered-file->buffer) - 9474 (clear-stream _test-output-stream) - 9475 (clear-stream $_test-output-buffered-file->buffer) - 9476 (clear-stream _test-error-stream) - 9477 (clear-stream $_test-error-buffered-file->buffer) - 9478 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9479 68/push 0/imm32 - 9480 68/push 0/imm32 - 9481 89/<- %edx 4/r32/esp - 9482 (tailor-exit-descriptor %edx 0x10) - 9483 # - 9484 (write _test-input-stream "fn foo {\n") - 9485 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n") - 9486 (write _test-input-stream " var b: boolean\n") - 9487 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n") - 9488 (write _test-input-stream "}\n") - 9489 # convert - 9490 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9491 # registers except esp clobbered at this point - 9492 # restore ed - 9493 89/<- %edx 4/r32/esp - 9494 (flush _test-output-buffered-file) - 9495 (flush _test-error-buffered-file) - 9496 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9502 # check output - 9503 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-index-type: output should be empty") - 9504 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: second argument 'b' must be an int or offset" "F - test-index-with-wrong-index-type: error message") - 9505 # check that stop(1) was called - 9506 (check-ints-equal *(edx+4) 2 "F - test-index-with-wrong-index-type: exit status") - 9507 # don't restore from ebp - 9508 81 0/subop/add %esp 8/imm32 - 9509 # . epilogue - 9510 5d/pop-to-ebp - 9511 c3/return - 9512 - 9513 test-index-with-offset-atom-index-type: - 9514 # . prologue - 9515 55/push-ebp - 9516 89/<- %ebp 4/r32/esp - 9517 # setup - 9518 (clear-stream _test-input-stream) - 9519 (clear-stream $_test-input-buffered-file->buffer) - 9520 (clear-stream _test-output-stream) - 9521 (clear-stream $_test-output-buffered-file->buffer) - 9522 (clear-stream _test-error-stream) - 9523 (clear-stream $_test-error-buffered-file->buffer) - 9524 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9525 68/push 0/imm32 - 9526 68/push 0/imm32 - 9527 89/<- %edx 4/r32/esp - 9528 (tailor-exit-descriptor %edx 0x10) - 9529 # - 9530 (write _test-input-stream "fn foo {\n") - 9531 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n") - 9532 (write _test-input-stream " var b: offset\n") - 9533 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n") - 9534 (write _test-input-stream "}\n") - 9535 # convert - 9536 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9537 # registers except esp clobbered at this point - 9538 # restore ed - 9539 89/<- %edx 4/r32/esp - 9540 (flush _test-output-buffered-file) - 9541 (flush _test-error-buffered-file) - 9542 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9548 # check output - 9549 (check-stream-equal _test-output-stream "" "F - test-index-with-offset-atom-index-type: output should be empty") - 9550 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: offset 'b' must specify the type of array elements" "F - test-index-with-offset-atom-index-type: error message") - 9551 # check that stop(1) was called - 9552 (check-ints-equal *(edx+4) 2 "F - test-index-with-offset-atom-index-type: exit status") - 9553 # don't restore from ebp - 9554 81 0/subop/add %esp 8/imm32 - 9555 # . epilogue - 9556 5d/pop-to-ebp - 9557 c3/return - 9558 - 9559 test-index-with-offset-on-stack: - 9560 # . prologue - 9561 55/push-ebp - 9562 89/<- %ebp 4/r32/esp - 9563 # setup - 9564 (clear-stream _test-input-stream) - 9565 (clear-stream $_test-input-buffered-file->buffer) - 9566 (clear-stream _test-output-stream) - 9567 (clear-stream $_test-output-buffered-file->buffer) - 9568 (clear-stream _test-error-stream) - 9569 (clear-stream $_test-error-buffered-file->buffer) - 9570 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9571 68/push 0/imm32 - 9572 68/push 0/imm32 - 9573 89/<- %edx 4/r32/esp - 9574 (tailor-exit-descriptor %edx 0x10) - 9575 # - 9576 (write _test-input-stream "fn foo {\n") - 9577 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n") - 9578 (write _test-input-stream " var b: int\n") - 9579 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n") - 9580 (write _test-input-stream "}\n") - 9581 # convert - 9582 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9583 # registers except esp clobbered at this point - 9584 # restore ed - 9585 89/<- %edx 4/r32/esp - 9586 (flush _test-output-buffered-file) - 9587 (flush _test-error-buffered-file) - 9588 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9594 # check output - 9595 (check-stream-equal _test-output-stream "" "F - test-index-with-offset-on-stack: output should be empty") - 9596 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: second argument 'b' must be in a register" "F - test-index-with-offset-on-stack: error message") - 9597 # check that stop(1) was called - 9598 (check-ints-equal *(edx+4) 2 "F - test-index-with-offset-on-stack: exit status") - 9599 # don't restore from ebp - 9600 81 0/subop/add %esp 8/imm32 - 9601 # . epilogue - 9602 5d/pop-to-ebp - 9603 c3/return - 9604 - 9605 test-index-needs-offset-type: - 9606 # . prologue - 9607 55/push-ebp - 9608 89/<- %ebp 4/r32/esp - 9609 # setup - 9610 (clear-stream _test-input-stream) - 9611 (clear-stream $_test-input-buffered-file->buffer) - 9612 (clear-stream _test-output-stream) - 9613 (clear-stream $_test-output-buffered-file->buffer) - 9614 (clear-stream _test-error-stream) - 9615 (clear-stream $_test-error-buffered-file->buffer) - 9616 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9617 68/push 0/imm32 - 9618 68/push 0/imm32 - 9619 89/<- %edx 4/r32/esp - 9620 (tailor-exit-descriptor %edx 0x10) - 9621 # - 9622 (write _test-input-stream "fn foo {\n") - 9623 (write _test-input-stream " var a/eax: (addr array t) <- copy 0\n") - 9624 (write _test-input-stream " var b/ebx: int <- copy 0\n") - 9625 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n") - 9626 (write _test-input-stream "}\n") - 9627 (write _test-input-stream "type t {\n") # size 12 is not a power of two - 9628 (write _test-input-stream " x: int\n") - 9629 (write _test-input-stream " y: int\n") - 9630 (write _test-input-stream " z: int\n") - 9631 (write _test-input-stream "}\n") - 9632 # convert - 9633 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9634 # registers except esp clobbered at this point - 9635 # restore ed - 9636 89/<- %edx 4/r32/esp + 8687 # convert + 8688 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 8689 (flush _test-output-buffered-file) + 8690 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8696 # not bothering checking output + 8697 (check-next-stream-line-equal _test-error-stream "" "F - test-address-of-deref: error message") + 8698 # . epilogue + 8699 5d/pop-to-ebp + 8700 c3/return + 8701 + 8702 test-address-to-non-register: + 8703 # . prologue + 8704 55/push-ebp + 8705 89/<- %ebp 4/r32/esp + 8706 # setup + 8707 (clear-stream _test-input-stream) + 8708 (clear-stream $_test-input-buffered-file->buffer) + 8709 (clear-stream _test-output-stream) + 8710 (clear-stream $_test-output-buffered-file->buffer) + 8711 (clear-stream _test-error-stream) + 8712 (clear-stream $_test-error-buffered-file->buffer) + 8713 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8714 68/push 0/imm32 + 8715 68/push 0/imm32 + 8716 89/<- %edx 4/r32/esp + 8717 (tailor-exit-descriptor %edx 0x10) + 8718 # + 8719 (write _test-input-stream "fn foo {\n") + 8720 (write _test-input-stream " var x: (addr int)\n") + 8721 (write _test-input-stream " x <- address 0\n") + 8722 (write _test-input-stream "}\n") + 8723 # convert + 8724 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8725 # registers except esp clobbered at this point + 8726 # restore ed + 8727 89/<- %edx 4/r32/esp + 8728 (flush _test-output-buffered-file) + 8729 (flush _test-error-buffered-file) + 8730 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8736 # check output + 8737 (check-stream-equal _test-output-stream "" "F - test-address-to-non-register: output should be empty") + 8738 (check-next-stream-line-equal _test-error-stream "fn foo: stmt address: output 'x' not in a register" "F - test-address-to-non-register: error message") + 8739 # check that stop(1) was called + 8740 (check-ints-equal *(edx+4) 2 "F - test-address-to-non-register: exit status") + 8741 # don't restore from ebp + 8742 81 0/subop/add %esp 8/imm32 + 8743 # . epilogue + 8744 5d/pop-to-ebp + 8745 c3/return + 8746 + 8747 test-address-with-wrong-type: + 8748 # . prologue + 8749 55/push-ebp + 8750 89/<- %ebp 4/r32/esp + 8751 # setup + 8752 (clear-stream _test-input-stream) + 8753 (clear-stream $_test-input-buffered-file->buffer) + 8754 (clear-stream _test-output-stream) + 8755 (clear-stream $_test-output-buffered-file->buffer) + 8756 (clear-stream _test-error-stream) + 8757 (clear-stream $_test-error-buffered-file->buffer) + 8758 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8759 68/push 0/imm32 + 8760 68/push 0/imm32 + 8761 89/<- %edx 4/r32/esp + 8762 (tailor-exit-descriptor %edx 0x10) + 8763 # + 8764 (write _test-input-stream "fn foo {\n") + 8765 (write _test-input-stream " var x: int\n") + 8766 (write _test-input-stream " var y/eax: (addr boolean) <- address x\n") + 8767 (write _test-input-stream "}\n") + 8768 # convert + 8769 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8770 # registers except esp clobbered at this point + 8771 # restore ed + 8772 89/<- %edx 4/r32/esp + 8773 (flush _test-output-buffered-file) + 8774 (flush _test-error-buffered-file) + 8775 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8781 # check output + 8782 (check-stream-equal _test-output-stream "" "F - test-address-with-wrong-type: output should be empty") + 8783 (check-next-stream-line-equal _test-error-stream "fn foo: stmt address: output 'y' cannot hold address of 'x'" "F - test-address-with-wrong-type: error message") + 8784 # check that stop(1) was called + 8785 (check-ints-equal *(edx+4) 2 "F - test-address-with-wrong-type: exit status") + 8786 # don't restore from ebp + 8787 81 0/subop/add %esp 8/imm32 + 8788 # . epilogue + 8789 5d/pop-to-ebp + 8790 c3/return + 8791 + 8792 test-address-with-right-type-for-array: + 8793 # . prologue + 8794 55/push-ebp + 8795 89/<- %ebp 4/r32/esp + 8796 # setup + 8797 (clear-stream _test-input-stream) + 8798 (clear-stream $_test-input-buffered-file->buffer) + 8799 (clear-stream _test-output-stream) + 8800 (clear-stream $_test-output-buffered-file->buffer) + 8801 # + 8802 (write _test-input-stream "fn foo {\n") + 8803 (write _test-input-stream " var x: (array int 3)\n") + 8804 (write _test-input-stream " var y/eax: (addr array int) <- address x\n") + 8805 (write _test-input-stream "}\n") + 8806 # convert + 8807 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 8808 (flush _test-output-buffered-file) + 8809 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8815 # no error + 8816 (check-next-stream-line-equal _test-error-stream "" "F - test-address-with-right-type-for-array: error message") + 8817 # don't bother checking output + 8818 # . epilogue + 8819 89/<- %esp 5/r32/ebp + 8820 5d/pop-to-ebp + 8821 c3/return + 8822 + 8823 test-address-with-right-type-for-stream: + 8824 # . prologue + 8825 55/push-ebp + 8826 89/<- %ebp 4/r32/esp + 8827 # setup + 8828 (clear-stream _test-input-stream) + 8829 (clear-stream $_test-input-buffered-file->buffer) + 8830 (clear-stream _test-output-stream) + 8831 (clear-stream $_test-output-buffered-file->buffer) + 8832 # + 8833 (write _test-input-stream "fn foo {\n") + 8834 (write _test-input-stream " var x: (stream int 3)\n") + 8835 (write _test-input-stream " var y/eax: (addr stream int) <- address x\n") + 8836 (write _test-input-stream "}\n") + 8837 # convert + 8838 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 8839 (flush _test-output-buffered-file) + 8840 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8846 # no error + 8847 (check-next-stream-line-equal _test-error-stream "" "F - test-address-with-right-type-for-stream: error message") + 8848 # don't bother checking output + 8849 # . epilogue + 8850 89/<- %esp 5/r32/ebp + 8851 5d/pop-to-ebp + 8852 c3/return + 8853 + 8854 test-get-with-wrong-field: + 8855 # . prologue + 8856 55/push-ebp + 8857 89/<- %ebp 4/r32/esp + 8858 # setup + 8859 (clear-stream _test-input-stream) + 8860 (clear-stream $_test-input-buffered-file->buffer) + 8861 (clear-stream _test-output-stream) + 8862 (clear-stream $_test-output-buffered-file->buffer) + 8863 (clear-stream _test-error-stream) + 8864 (clear-stream $_test-error-buffered-file->buffer) + 8865 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8866 68/push 0/imm32 + 8867 68/push 0/imm32 + 8868 89/<- %edx 4/r32/esp + 8869 (tailor-exit-descriptor %edx 0x10) + 8870 # + 8871 (write _test-input-stream "fn foo {\n") + 8872 (write _test-input-stream " var a: t\n") + 8873 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 8874 (write _test-input-stream "}\n") + 8875 (write _test-input-stream "type t {\n") + 8876 (write _test-input-stream " x: int\n") + 8877 (write _test-input-stream "}\n") + 8878 # convert + 8879 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8880 # registers except esp clobbered at this point + 8881 # restore ed + 8882 89/<- %edx 4/r32/esp + 8883 (flush _test-output-buffered-file) + 8884 (flush _test-error-buffered-file) + 8885 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8891 # check output + 8892 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-field: output should be empty") + 8893 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'y'" "F - test-get-with-wrong-field: error message") + 8894 # check that stop(1) was called + 8895 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-field: exit status") + 8896 # don't restore from ebp + 8897 81 0/subop/add %esp 8/imm32 + 8898 # . epilogue + 8899 5d/pop-to-ebp + 8900 c3/return + 8901 + 8902 test-get-with-wrong-base-type: + 8903 # . prologue + 8904 55/push-ebp + 8905 89/<- %ebp 4/r32/esp + 8906 # setup + 8907 (clear-stream _test-input-stream) + 8908 (clear-stream $_test-input-buffered-file->buffer) + 8909 (clear-stream _test-output-stream) + 8910 (clear-stream $_test-output-buffered-file->buffer) + 8911 (clear-stream _test-error-stream) + 8912 (clear-stream $_test-error-buffered-file->buffer) + 8913 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8914 68/push 0/imm32 + 8915 68/push 0/imm32 + 8916 89/<- %edx 4/r32/esp + 8917 (tailor-exit-descriptor %edx 0x10) + 8918 # + 8919 (write _test-input-stream "fn foo {\n") + 8920 (write _test-input-stream " var a: int\n") + 8921 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 8922 (write _test-input-stream "}\n") + 8923 # convert + 8924 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8925 # registers except esp clobbered at this point + 8926 # restore ed + 8927 89/<- %edx 4/r32/esp + 8928 (flush _test-output-buffered-file) + 8929 (flush _test-error-buffered-file) + 8930 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8936 # check output + 8937 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type: output should be empty") + 8938 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' must have a 'type' definition" "F - test-get-with-wrong-base-type: error message") + 8939 # check that stop(1) was called + 8940 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type: exit status") + 8941 # don't restore from ebp + 8942 81 0/subop/add %esp 8/imm32 + 8943 # . epilogue + 8944 5d/pop-to-ebp + 8945 c3/return + 8946 + 8947 test-get-with-wrong-base-type-2: + 8948 # . prologue + 8949 55/push-ebp + 8950 89/<- %ebp 4/r32/esp + 8951 # setup + 8952 (clear-stream _test-input-stream) + 8953 (clear-stream $_test-input-buffered-file->buffer) + 8954 (clear-stream _test-output-stream) + 8955 (clear-stream $_test-output-buffered-file->buffer) + 8956 (clear-stream _test-error-stream) + 8957 (clear-stream $_test-error-buffered-file->buffer) + 8958 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 8959 68/push 0/imm32 + 8960 68/push 0/imm32 + 8961 89/<- %edx 4/r32/esp + 8962 (tailor-exit-descriptor %edx 0x10) + 8963 # + 8964 (write _test-input-stream "fn foo {\n") + 8965 (write _test-input-stream " var a: (addr t)\n") + 8966 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 8967 (write _test-input-stream "}\n") + 8968 (write _test-input-stream "type t {\n") + 8969 (write _test-input-stream " x: int\n") + 8970 (write _test-input-stream "}\n") + 8971 # convert + 8972 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 8973 # registers except esp clobbered at this point + 8974 # restore ed + 8975 89/<- %edx 4/r32/esp + 8976 (flush _test-output-buffered-file) + 8977 (flush _test-error-buffered-file) + 8978 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 8984 # check output + 8985 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type-2: output should be empty") + 8986 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' is an 'addr' type, and so must live in a register" "F - test-get-with-wrong-base-type-2: error message") + 8987 # check that stop(1) was called + 8988 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type-2: exit status") + 8989 # don't restore from ebp + 8990 81 0/subop/add %esp 8/imm32 + 8991 # . epilogue + 8992 5d/pop-to-ebp + 8993 c3/return + 8994 + 8995 test-get-with-wrong-base-type-3: + 8996 # . prologue + 8997 55/push-ebp + 8998 89/<- %ebp 4/r32/esp + 8999 # setup + 9000 (clear-stream _test-input-stream) + 9001 (clear-stream $_test-input-buffered-file->buffer) + 9002 (clear-stream _test-output-stream) + 9003 (clear-stream $_test-output-buffered-file->buffer) + 9004 (clear-stream _test-error-stream) + 9005 (clear-stream $_test-error-buffered-file->buffer) + 9006 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9007 68/push 0/imm32 + 9008 68/push 0/imm32 + 9009 89/<- %edx 4/r32/esp + 9010 (tailor-exit-descriptor %edx 0x10) + 9011 # + 9012 (write _test-input-stream "fn foo {\n") + 9013 (write _test-input-stream " var a: (handle int)\n") + 9014 (write _test-input-stream " var c/ecx: (addr int) <- get a, y\n") + 9015 (write _test-input-stream "}\n") + 9016 # convert + 9017 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9018 # registers except esp clobbered at this point + 9019 # restore ed + 9020 89/<- %edx 4/r32/esp + 9021 (flush _test-output-buffered-file) + 9022 (flush _test-error-buffered-file) + 9023 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9029 # check output + 9030 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-base-type-3: output should be empty") + 9031 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: var 'a' must have a 'type' definition" "F - test-get-with-wrong-base-type-3: error message") + 9032 # check that stop(1) was called + 9033 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-base-type-3: exit status") + 9034 # don't restore from ebp + 9035 81 0/subop/add %esp 8/imm32 + 9036 # . epilogue + 9037 5d/pop-to-ebp + 9038 c3/return + 9039 + 9040 test-get-with-wrong-offset-type: + 9041 # . prologue + 9042 55/push-ebp + 9043 89/<- %ebp 4/r32/esp + 9044 # setup + 9045 (clear-stream _test-input-stream) + 9046 (clear-stream $_test-input-buffered-file->buffer) + 9047 (clear-stream _test-output-stream) + 9048 (clear-stream $_test-output-buffered-file->buffer) + 9049 (clear-stream _test-error-stream) + 9050 (clear-stream $_test-error-buffered-file->buffer) + 9051 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9052 68/push 0/imm32 + 9053 68/push 0/imm32 + 9054 89/<- %edx 4/r32/esp + 9055 (tailor-exit-descriptor %edx 0x10) + 9056 # + 9057 (write _test-input-stream "fn foo {\n") + 9058 (write _test-input-stream " var a: t\n") + 9059 (write _test-input-stream " var b: int\n") + 9060 (write _test-input-stream " var c/ecx: (addr int) <- get a, b\n") + 9061 (write _test-input-stream "}\n") + 9062 (write _test-input-stream "type t {\n") + 9063 (write _test-input-stream " x: int\n") + 9064 (write _test-input-stream "}\n") + 9065 # convert + 9066 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9067 # registers except esp clobbered at this point + 9068 # restore ed + 9069 89/<- %edx 4/r32/esp + 9070 (flush _test-output-buffered-file) + 9071 (flush _test-error-buffered-file) + 9072 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9078 # check output + 9079 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-offset-type: output should be empty") + 9080 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: type 't' has no member called 'b'" "F - test-get-with-wrong-offset-type: error message") + 9081 # check that stop(1) was called + 9082 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-offset-type: exit status") + 9083 # don't restore from ebp + 9084 81 0/subop/add %esp 8/imm32 + 9085 # . epilogue + 9086 5d/pop-to-ebp + 9087 c3/return + 9088 + 9089 test-get-with-wrong-output-type: + 9090 # . prologue + 9091 55/push-ebp + 9092 89/<- %ebp 4/r32/esp + 9093 # setup + 9094 (clear-stream _test-input-stream) + 9095 (clear-stream $_test-input-buffered-file->buffer) + 9096 (clear-stream _test-output-stream) + 9097 (clear-stream $_test-output-buffered-file->buffer) + 9098 (clear-stream _test-error-stream) + 9099 (clear-stream $_test-error-buffered-file->buffer) + 9100 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9101 68/push 0/imm32 + 9102 68/push 0/imm32 + 9103 89/<- %edx 4/r32/esp + 9104 (tailor-exit-descriptor %edx 0x10) + 9105 # + 9106 (write _test-input-stream "fn foo {\n") + 9107 (write _test-input-stream " var a: t\n") + 9108 (write _test-input-stream " var c: (addr int)\n") + 9109 (write _test-input-stream " c <- get a, x\n") + 9110 (write _test-input-stream "}\n") + 9111 (write _test-input-stream "type t {\n") + 9112 (write _test-input-stream " x: int\n") + 9113 (write _test-input-stream "}\n") + 9114 # convert + 9115 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9116 # registers except esp clobbered at this point + 9117 # restore ed + 9118 89/<- %edx 4/r32/esp + 9119 (flush _test-output-buffered-file) + 9120 (flush _test-error-buffered-file) + 9121 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9127 # check output + 9128 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type: output should be empty") + 9129 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output 'c' is not in a register" "F - test-get-with-wrong-output-type: error message") + 9130 # check that stop(1) was called + 9131 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type: exit status") + 9132 # don't restore from ebp + 9133 81 0/subop/add %esp 8/imm32 + 9134 # . epilogue + 9135 5d/pop-to-ebp + 9136 c3/return + 9137 + 9138 test-get-with-wrong-output-type-2: + 9139 # . prologue + 9140 55/push-ebp + 9141 89/<- %ebp 4/r32/esp + 9142 # setup + 9143 (clear-stream _test-input-stream) + 9144 (clear-stream $_test-input-buffered-file->buffer) + 9145 (clear-stream _test-output-stream) + 9146 (clear-stream $_test-output-buffered-file->buffer) + 9147 (clear-stream _test-error-stream) + 9148 (clear-stream $_test-error-buffered-file->buffer) + 9149 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9150 68/push 0/imm32 + 9151 68/push 0/imm32 + 9152 89/<- %edx 4/r32/esp + 9153 (tailor-exit-descriptor %edx 0x10) + 9154 # + 9155 (write _test-input-stream "fn foo {\n") + 9156 (write _test-input-stream " var a: t\n") + 9157 (write _test-input-stream " var c/ecx: int <- get a, x\n") + 9158 (write _test-input-stream "}\n") + 9159 (write _test-input-stream "type t {\n") + 9160 (write _test-input-stream " x: int\n") + 9161 (write _test-input-stream "}\n") + 9162 # convert + 9163 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9164 # registers except esp clobbered at this point + 9165 # restore ed + 9166 89/<- %edx 4/r32/esp + 9167 (flush _test-output-buffered-file) + 9168 (flush _test-error-buffered-file) + 9169 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9175 # check output + 9176 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-2: output should be empty") + 9177 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an addr" "F - test-get-with-wrong-output-type-2: error message") + 9178 # check that stop(1) was called + 9179 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-2: exit status") + 9180 # don't restore from ebp + 9181 81 0/subop/add %esp 8/imm32 + 9182 # . epilogue + 9183 5d/pop-to-ebp + 9184 c3/return + 9185 + 9186 test-get-with-wrong-output-type-3: + 9187 # . prologue + 9188 55/push-ebp + 9189 89/<- %ebp 4/r32/esp + 9190 # setup + 9191 (clear-stream _test-input-stream) + 9192 (clear-stream $_test-input-buffered-file->buffer) + 9193 (clear-stream _test-output-stream) + 9194 (clear-stream $_test-output-buffered-file->buffer) + 9195 (clear-stream _test-error-stream) + 9196 (clear-stream $_test-error-buffered-file->buffer) + 9197 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9198 68/push 0/imm32 + 9199 68/push 0/imm32 + 9200 89/<- %edx 4/r32/esp + 9201 (tailor-exit-descriptor %edx 0x10) + 9202 # + 9203 (write _test-input-stream "fn foo {\n") + 9204 (write _test-input-stream " var a: t\n") + 9205 (write _test-input-stream " var c/ecx: (array int) <- get a, x\n") + 9206 (write _test-input-stream "}\n") + 9207 (write _test-input-stream "type t {\n") + 9208 (write _test-input-stream " x: int\n") + 9209 (write _test-input-stream "}\n") + 9210 # convert + 9211 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9212 # registers except esp clobbered at this point + 9213 # restore ed + 9214 89/<- %edx 4/r32/esp + 9215 (flush _test-output-buffered-file) + 9216 (flush _test-error-buffered-file) + 9217 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9223 # check output + 9224 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-3: output should be empty") + 9225 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: output must be an addr" "F - test-get-with-wrong-output-type-3: error message") + 9226 # check that stop(1) was called + 9227 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-3: exit status") + 9228 # don't restore from ebp + 9229 81 0/subop/add %esp 8/imm32 + 9230 # . epilogue + 9231 5d/pop-to-ebp + 9232 c3/return + 9233 + 9234 test-get-with-wrong-output-type-4: + 9235 # . prologue + 9236 55/push-ebp + 9237 89/<- %ebp 4/r32/esp + 9238 # setup + 9239 (clear-stream _test-input-stream) + 9240 (clear-stream $_test-input-buffered-file->buffer) + 9241 (clear-stream _test-output-stream) + 9242 (clear-stream $_test-output-buffered-file->buffer) + 9243 (clear-stream _test-error-stream) + 9244 (clear-stream $_test-error-buffered-file->buffer) + 9245 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9246 68/push 0/imm32 + 9247 68/push 0/imm32 + 9248 89/<- %edx 4/r32/esp + 9249 (tailor-exit-descriptor %edx 0x10) + 9250 # + 9251 (write _test-input-stream "fn foo {\n") + 9252 (write _test-input-stream " var a: t\n") + 9253 (write _test-input-stream " var c/ecx: (addr boolean) <- get a, x\n") + 9254 (write _test-input-stream "}\n") + 9255 (write _test-input-stream "type t {\n") + 9256 (write _test-input-stream " x: int\n") + 9257 (write _test-input-stream "}\n") + 9258 # convert + 9259 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9260 # registers except esp clobbered at this point + 9261 # restore ed + 9262 89/<- %edx 4/r32/esp + 9263 (flush _test-output-buffered-file) + 9264 (flush _test-error-buffered-file) + 9265 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9271 # check output + 9272 (check-stream-equal _test-output-stream "" "F - test-get-with-wrong-output-type-4: output should be empty") + 9273 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: wrong output type for member 'x' of type 't'" "F - test-get-with-wrong-output-type-4: error message") + 9274 # check that stop(1) was called + 9275 (check-ints-equal *(edx+4) 2 "F - test-get-with-wrong-output-type-4: exit status") + 9276 # don't restore from ebp + 9277 81 0/subop/add %esp 8/imm32 + 9278 # . epilogue + 9279 5d/pop-to-ebp + 9280 c3/return + 9281 + 9282 test-get-with-wrong-output-type-5: + 9283 # . prologue + 9284 55/push-ebp + 9285 89/<- %ebp 4/r32/esp + 9286 # setup + 9287 (clear-stream _test-input-stream) + 9288 (clear-stream $_test-input-buffered-file->buffer) + 9289 (clear-stream _test-output-stream) + 9290 (clear-stream $_test-output-buffered-file->buffer) + 9291 # + 9292 (write _test-input-stream "fn foo {\n") + 9293 (write _test-input-stream " var a: t\n") + 9294 (write _test-input-stream " var c/ecx: (addr handle int) <- get a, x\n") + 9295 (write _test-input-stream "}\n") + 9296 (write _test-input-stream "type t {\n") + 9297 (write _test-input-stream " x: (handle int)\n") + 9298 (write _test-input-stream "}\n") + 9299 # convert + 9300 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 9301 (flush _test-output-buffered-file) + 9302 # no errors + 9303 # . epilogue + 9304 89/<- %esp 5/r32/ebp + 9305 5d/pop-to-ebp + 9306 c3/return + 9307 + 9308 test-get-with-too-few-inouts: + 9309 # . prologue + 9310 55/push-ebp + 9311 89/<- %ebp 4/r32/esp + 9312 # setup + 9313 (clear-stream _test-input-stream) + 9314 (clear-stream $_test-input-buffered-file->buffer) + 9315 (clear-stream _test-output-stream) + 9316 (clear-stream $_test-output-buffered-file->buffer) + 9317 (clear-stream _test-error-stream) + 9318 (clear-stream $_test-error-buffered-file->buffer) + 9319 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9320 68/push 0/imm32 + 9321 68/push 0/imm32 + 9322 89/<- %edx 4/r32/esp + 9323 (tailor-exit-descriptor %edx 0x10) + 9324 # + 9325 (write _test-input-stream "fn foo {\n") + 9326 (write _test-input-stream " var a: t\n") + 9327 (write _test-input-stream " var c/ecx: (addr int) <- get a\n") + 9328 (write _test-input-stream "}\n") + 9329 (write _test-input-stream "type t {\n") + 9330 (write _test-input-stream " x: int\n") + 9331 (write _test-input-stream "}\n") + 9332 # convert + 9333 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9334 # registers except esp clobbered at this point + 9335 # restore ed + 9336 89/<- %edx 4/r32/esp + 9337 (flush _test-output-buffered-file) + 9338 (flush _test-error-buffered-file) + 9339 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9345 # check output + 9346 (check-stream-equal _test-output-stream "" "F - test-get-with-too-few-inouts: output should be empty") + 9347 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too few inouts (2 required)" "F - test-get-with-too-few-inouts: error message") + 9348 # check that stop(1) was called + 9349 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-few-inouts: exit status") + 9350 # don't restore from ebp + 9351 81 0/subop/add %esp 8/imm32 + 9352 # . epilogue + 9353 5d/pop-to-ebp + 9354 c3/return + 9355 + 9356 test-get-with-too-many-inouts: + 9357 # . prologue + 9358 55/push-ebp + 9359 89/<- %ebp 4/r32/esp + 9360 # setup + 9361 (clear-stream _test-input-stream) + 9362 (clear-stream $_test-input-buffered-file->buffer) + 9363 (clear-stream _test-output-stream) + 9364 (clear-stream $_test-output-buffered-file->buffer) + 9365 (clear-stream _test-error-stream) + 9366 (clear-stream $_test-error-buffered-file->buffer) + 9367 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9368 68/push 0/imm32 + 9369 68/push 0/imm32 + 9370 89/<- %edx 4/r32/esp + 9371 (tailor-exit-descriptor %edx 0x10) + 9372 # + 9373 (write _test-input-stream "fn foo {\n") + 9374 (write _test-input-stream " var a: t\n") + 9375 (write _test-input-stream " var c/ecx: (addr int) <- get a, x, 0\n") + 9376 (write _test-input-stream "}\n") + 9377 (write _test-input-stream "type t {\n") + 9378 (write _test-input-stream " x: int\n") + 9379 (write _test-input-stream "}\n") + 9380 # convert + 9381 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9382 # registers except esp clobbered at this point + 9383 # restore ed + 9384 89/<- %edx 4/r32/esp + 9385 (flush _test-output-buffered-file) + 9386 (flush _test-error-buffered-file) + 9387 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9393 # check output + 9394 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-inouts: output should be empty") + 9395 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many inouts (2 required)" "F - test-get-with-too-many-inouts: error message") + 9396 # check that stop(1) was called + 9397 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-inouts: exit status") + 9398 # don't restore from ebp + 9399 81 0/subop/add %esp 8/imm32 + 9400 # . epilogue + 9401 5d/pop-to-ebp + 9402 c3/return + 9403 + 9404 test-get-with-no-output: + 9405 # . prologue + 9406 55/push-ebp + 9407 89/<- %ebp 4/r32/esp + 9408 # setup + 9409 (clear-stream _test-input-stream) + 9410 (clear-stream $_test-input-buffered-file->buffer) + 9411 (clear-stream _test-output-stream) + 9412 (clear-stream $_test-output-buffered-file->buffer) + 9413 (clear-stream _test-error-stream) + 9414 (clear-stream $_test-error-buffered-file->buffer) + 9415 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9416 68/push 0/imm32 + 9417 68/push 0/imm32 + 9418 89/<- %edx 4/r32/esp + 9419 (tailor-exit-descriptor %edx 0x10) + 9420 # + 9421 (write _test-input-stream "fn foo {\n") + 9422 (write _test-input-stream " var a: t\n") + 9423 (write _test-input-stream " get a, x\n") + 9424 (write _test-input-stream "}\n") + 9425 (write _test-input-stream "type t {\n") + 9426 (write _test-input-stream " x: int\n") + 9427 (write _test-input-stream "}\n") + 9428 # convert + 9429 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9430 # registers except esp clobbered at this point + 9431 # restore ed + 9432 89/<- %edx 4/r32/esp + 9433 (flush _test-output-buffered-file) + 9434 (flush _test-error-buffered-file) + 9435 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9441 # check output + 9442 (check-stream-equal _test-output-stream "" "F - test-get-with-no-output: output should be empty") + 9443 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: must have an output" "F - test-get-with-no-output: error message") + 9444 # check that stop(1) was called + 9445 (check-ints-equal *(edx+4) 2 "F - test-get-with-no-output: exit status") + 9446 # don't restore from ebp + 9447 81 0/subop/add %esp 8/imm32 + 9448 # . epilogue + 9449 5d/pop-to-ebp + 9450 c3/return + 9451 + 9452 test-get-with-too-many-outputs: + 9453 # . prologue + 9454 55/push-ebp + 9455 89/<- %ebp 4/r32/esp + 9456 # setup + 9457 (clear-stream _test-input-stream) + 9458 (clear-stream $_test-input-buffered-file->buffer) + 9459 (clear-stream _test-output-stream) + 9460 (clear-stream $_test-output-buffered-file->buffer) + 9461 (clear-stream _test-error-stream) + 9462 (clear-stream $_test-error-buffered-file->buffer) + 9463 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9464 68/push 0/imm32 + 9465 68/push 0/imm32 + 9466 89/<- %edx 4/r32/esp + 9467 (tailor-exit-descriptor %edx 0x10) + 9468 # + 9469 (write _test-input-stream "fn foo {\n") + 9470 (write _test-input-stream " var a: t\n") + 9471 (write _test-input-stream " var b: int\n") + 9472 (write _test-input-stream " var c/eax: (addr int) <- copy 0\n") + 9473 (write _test-input-stream " c, b <- get a, x\n") + 9474 (write _test-input-stream "}\n") + 9475 (write _test-input-stream "type t {\n") + 9476 (write _test-input-stream " x: int\n") + 9477 (write _test-input-stream "}\n") + 9478 # convert + 9479 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9480 # registers except esp clobbered at this point + 9481 # restore ed + 9482 89/<- %edx 4/r32/esp + 9483 (flush _test-output-buffered-file) + 9484 (flush _test-error-buffered-file) + 9485 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9491 # check output + 9492 (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-outputs: output should be empty") + 9493 (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many outputs (1 required)" "F - test-get-with-too-many-outputs: error message") + 9494 # check that stop(1) was called + 9495 (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-outputs: exit status") + 9496 # don't restore from ebp + 9497 81 0/subop/add %esp 8/imm32 + 9498 # . epilogue + 9499 5d/pop-to-ebp + 9500 c3/return + 9501 + 9502 test-convert-array-of-user-defined-types: + 9503 # . prologue + 9504 55/push-ebp + 9505 89/<- %ebp 4/r32/esp + 9506 # setup + 9507 (clear-stream _test-input-stream) + 9508 (clear-stream $_test-input-buffered-file->buffer) + 9509 (clear-stream _test-output-stream) + 9510 (clear-stream $_test-output-buffered-file->buffer) + 9511 # + 9512 (write _test-input-stream "type t {\n") # each t is 8 bytes, which is a power of 2 + 9513 (write _test-input-stream " x: int\n") + 9514 (write _test-input-stream " y: int\n") + 9515 (write _test-input-stream "}\n") + 9516 (write _test-input-stream "fn foo {\n") + 9517 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 9518 (write _test-input-stream " var idx/ecx: int <- copy 3\n") + 9519 (write _test-input-stream " var x/eax: (addr t) <- index arr, idx\n") + 9520 (write _test-input-stream "}\n") + 9521 # convert + 9522 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 9523 (flush _test-output-buffered-file) + 9524 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9530 # check output + 9531 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-array-of-user-defined-types/0") + 9532 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-array-of-user-defined-types/1") + 9533 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-array-of-user-defined-types/2") + 9534 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-array-of-user-defined-types/3") + 9535 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-array-of-user-defined-types/4") + 9536 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-array-of-user-defined-types/5") + 9537 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-array-of-user-defined-types/6") + 9538 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-array-of-user-defined-types/7") + 9539 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-array-of-user-defined-types/8") + 9540 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 3/imm32" "F - test-convert-array-of-user-defined-types/9") + 9541 (check-next-stream-line-equal _test-output-stream " 8d/copy-address *(eax + ecx<<0x00000003 + 4) 0x00000000/r32" "F - test-convert-array-of-user-defined-types/11") + 9542 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-array-of-user-defined-types/13") + 9543 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-array-of-user-defined-types/14") + 9544 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-array-of-user-defined-types/15") + 9545 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-array-of-user-defined-types/16") + 9546 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-array-of-user-defined-types/17") + 9547 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-array-of-user-defined-types/18") + 9548 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-array-of-user-defined-types/19") + 9549 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-array-of-user-defined-types/20") + 9550 # . epilogue + 9551 89/<- %esp 5/r32/ebp + 9552 5d/pop-to-ebp + 9553 c3/return + 9554 + 9555 test-convert-length-of-array-of-user-defined-types-to-eax: + 9556 # . prologue + 9557 55/push-ebp + 9558 89/<- %ebp 4/r32/esp + 9559 # setup + 9560 (clear-stream _test-input-stream) + 9561 (clear-stream $_test-input-buffered-file->buffer) + 9562 (clear-stream _test-output-stream) + 9563 (clear-stream $_test-output-buffered-file->buffer) + 9564 # + 9565 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 + 9566 (write _test-input-stream " x: int\n") + 9567 (write _test-input-stream " y: int\n") + 9568 (write _test-input-stream " z: int\n") + 9569 (write _test-input-stream "}\n") + 9570 (write _test-input-stream "fn foo {\n") + 9571 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 9572 (write _test-input-stream " var x/eax: int <- length arr\n") + 9573 (write _test-input-stream "}\n") + 9574 # convert + 9575 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 9576 (flush _test-output-buffered-file) + 9577 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9583 # check output + 9584 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/0") + 9585 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/1") + 9586 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/2") + 9587 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/3") + 9588 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-eax/4") + 9589 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/5") + 9590 # var arr + 9591 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/6") + 9592 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/7") + 9593 # length instruction + 9594 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/8") + 9595 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/9") + 9596 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/10") + 9597 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/11") + 9598 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-eax/12") + 9599 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/13") + 9600 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/14") + 9601 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-eax/15") + 9602 # reclaim arr + 9603 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-eax/16") + 9604 # + 9605 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-eax/17") + 9606 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-eax/18") + 9607 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-eax/19") + 9608 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/20") + 9609 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-eax/21") + 9610 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-eax/22") + 9611 # . epilogue + 9612 89/<- %esp 5/r32/ebp + 9613 5d/pop-to-ebp + 9614 c3/return + 9615 + 9616 test-convert-length-of-array-of-user-defined-types-to-ecx: + 9617 # . prologue + 9618 55/push-ebp + 9619 89/<- %ebp 4/r32/esp + 9620 # setup + 9621 (clear-stream _test-input-stream) + 9622 (clear-stream $_test-input-buffered-file->buffer) + 9623 (clear-stream _test-output-stream) + 9624 (clear-stream $_test-output-buffered-file->buffer) + 9625 # + 9626 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 + 9627 (write _test-input-stream " x: int\n") + 9628 (write _test-input-stream " y: int\n") + 9629 (write _test-input-stream " z: int\n") + 9630 (write _test-input-stream "}\n") + 9631 (write _test-input-stream "fn foo {\n") + 9632 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 9633 (write _test-input-stream " var x/ecx: int <- length arr\n") + 9634 (write _test-input-stream "}\n") + 9635 # convert + 9636 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) 9637 (flush _test-output-buffered-file) - 9638 (flush _test-error-buffered-file) - 9639 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9645 # check output - 9646 (check-stream-equal _test-output-stream "" "F - test-index-needs-offset-type: output should be empty") - 9647 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: cannot take an int for array 'a'; create an offset instead. See mu.md for details." "F - test-index-needs-offset-type: error message") - 9648 # check that stop(1) was called - 9649 (check-ints-equal *(edx+4) 2 "F - test-index-needs-offset-type: exit status") - 9650 # don't restore from ebp - 9651 81 0/subop/add %esp 8/imm32 - 9652 # . epilogue - 9653 5d/pop-to-ebp - 9654 c3/return - 9655 - 9656 test-index-with-output-not-address: - 9657 # . prologue - 9658 55/push-ebp - 9659 89/<- %ebp 4/r32/esp - 9660 # setup - 9661 (clear-stream _test-input-stream) - 9662 (clear-stream $_test-input-buffered-file->buffer) - 9663 (clear-stream _test-output-stream) - 9664 (clear-stream $_test-output-buffered-file->buffer) - 9665 (clear-stream _test-error-stream) - 9666 (clear-stream $_test-error-buffered-file->buffer) - 9667 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9668 68/push 0/imm32 - 9669 68/push 0/imm32 - 9670 89/<- %edx 4/r32/esp - 9671 (tailor-exit-descriptor %edx 0x10) - 9672 # - 9673 (write _test-input-stream "fn foo {\n") - 9674 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") - 9675 (write _test-input-stream " var o/edi: int <- index a, 0\n") - 9676 (write _test-input-stream "}\n") - 9677 # convert - 9678 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9679 # registers except esp clobbered at this point - 9680 # restore ed - 9681 89/<- %edx 4/r32/esp - 9682 (flush _test-output-buffered-file) - 9683 (flush _test-error-buffered-file) - 9684 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9690 # check output - 9691 (check-stream-equal _test-output-stream "" "F - test-index-with-output-not-address: output should be empty") - 9692 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' must be an addr" "F - test-index-with-output-not-address: error message") - 9693 # check that stop(1) was called - 9694 (check-ints-equal *(edx+4) 2 "F - test-index-with-output-not-address: exit status") - 9695 # don't restore from ebp - 9696 81 0/subop/add %esp 8/imm32 - 9697 # . epilogue - 9698 5d/pop-to-ebp - 9699 c3/return - 9700 - 9701 test-index-with-output-not-address-2: - 9702 # . prologue - 9703 55/push-ebp - 9704 89/<- %ebp 4/r32/esp - 9705 # setup - 9706 (clear-stream _test-input-stream) - 9707 (clear-stream $_test-input-buffered-file->buffer) - 9708 (clear-stream _test-output-stream) - 9709 (clear-stream $_test-output-buffered-file->buffer) - 9710 (clear-stream _test-error-stream) - 9711 (clear-stream $_test-error-buffered-file->buffer) - 9712 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9713 68/push 0/imm32 - 9714 68/push 0/imm32 - 9715 89/<- %edx 4/r32/esp - 9716 (tailor-exit-descriptor %edx 0x10) - 9717 # - 9718 (write _test-input-stream "fn foo {\n") - 9719 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") - 9720 (write _test-input-stream " var o/edi: (int) <- index a, 0\n") - 9721 (write _test-input-stream "}\n") - 9722 # convert - 9723 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9724 # registers except esp clobbered at this point - 9725 # restore ed - 9726 89/<- %edx 4/r32/esp - 9727 (flush _test-output-buffered-file) - 9728 (flush _test-error-buffered-file) - 9729 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9735 # check output - 9736 (check-stream-equal _test-output-stream "" "F - test-index-with-output-not-address-2: output should be empty") - 9737 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' must be an addr" "F - test-index-with-output-not-address-2: error message") - 9738 # check that stop(1) was called - 9739 (check-ints-equal *(edx+4) 2 "F - test-index-with-output-not-address-2: exit status") - 9740 # don't restore from ebp - 9741 81 0/subop/add %esp 8/imm32 - 9742 # . epilogue - 9743 5d/pop-to-ebp - 9744 c3/return - 9745 - 9746 test-index-with-wrong-output-type: - 9747 # . prologue - 9748 55/push-ebp - 9749 89/<- %ebp 4/r32/esp - 9750 # setup - 9751 (clear-stream _test-input-stream) - 9752 (clear-stream $_test-input-buffered-file->buffer) - 9753 (clear-stream _test-output-stream) - 9754 (clear-stream $_test-output-buffered-file->buffer) - 9755 (clear-stream _test-error-stream) - 9756 (clear-stream $_test-error-buffered-file->buffer) - 9757 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9758 68/push 0/imm32 - 9759 68/push 0/imm32 - 9760 89/<- %edx 4/r32/esp - 9761 (tailor-exit-descriptor %edx 0x10) - 9762 # + 9638 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9644 # check output + 9645 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/0") + 9646 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/1") + 9647 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/2") + 9648 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/3") + 9649 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/4") + 9650 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/5") + 9651 # var a + 9652 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/6") + 9653 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/7") + 9654 # var x + 9655 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/8") + 9656 # length instruction + 9657 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/9") + 9658 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/10") + 9659 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/11") + 9660 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/12") + 9661 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/13") + 9662 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/14") + 9663 (check-next-stream-line-equal _test-output-stream " 89/<- %ecx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/15") + 9664 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/16") + 9665 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/17") + 9666 # reclaim x + 9667 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/18") + 9668 # reclaim a + 9669 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/19") + 9670 # + 9671 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/20") + 9672 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/21") + 9673 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/22") + 9674 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/23") + 9675 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/24") + 9676 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-ecx/25") + 9677 # . epilogue + 9678 89/<- %esp 5/r32/ebp + 9679 5d/pop-to-ebp + 9680 c3/return + 9681 + 9682 test-convert-length-of-array-of-user-defined-types-to-edx: + 9683 # . prologue + 9684 55/push-ebp + 9685 89/<- %ebp 4/r32/esp + 9686 # setup + 9687 (clear-stream _test-input-stream) + 9688 (clear-stream $_test-input-buffered-file->buffer) + 9689 (clear-stream _test-output-stream) + 9690 (clear-stream $_test-output-buffered-file->buffer) + 9691 # + 9692 (write _test-input-stream "type t {\n") # size = 12, which is not a power of 2 + 9693 (write _test-input-stream " x: int\n") + 9694 (write _test-input-stream " y: int\n") + 9695 (write _test-input-stream " z: int\n") + 9696 (write _test-input-stream "}\n") + 9697 (write _test-input-stream "fn foo {\n") + 9698 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 9699 (write _test-input-stream " var x/edx: int <- length arr\n") + 9700 (write _test-input-stream "}\n") + 9701 # convert + 9702 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 9703 (flush _test-output-buffered-file) + 9704 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9710 # check output + 9711 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/0") + 9712 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/1") + 9713 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/2") + 9714 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/3") + 9715 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types-to-edx/4") + 9716 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/5") + 9717 # var a + 9718 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/6") + 9719 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/7") + 9720 # var x + 9721 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/8") + 9722 # length instruction + 9723 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/9") + 9724 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/10") + 9725 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/11") + 9726 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/12") + 9727 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types-to-edx/13") + 9728 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/14") + 9729 (check-next-stream-line-equal _test-output-stream " 89/<- %edx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/15") + 9730 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/16") + 9731 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/17") + 9732 # reclaim x + 9733 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %edx" "F - test-convert-length-of-array-of-user-defined-types-to-edx/18") + 9734 # reclaim a + 9735 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types-to-edx/19") + 9736 # + 9737 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types-to-edx/20") + 9738 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types-to-edx/21") + 9739 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types-to-edx/22") + 9740 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/23") + 9741 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types-to-edx/24") + 9742 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types-to-edx/25") + 9743 # . epilogue + 9744 89/<- %esp 5/r32/ebp + 9745 5d/pop-to-ebp + 9746 c3/return + 9747 + 9748 test-convert-length-of-array-of-user-defined-types: + 9749 # . prologue + 9750 55/push-ebp + 9751 89/<- %ebp 4/r32/esp + 9752 # setup + 9753 (clear-stream _test-input-stream) + 9754 (clear-stream $_test-input-buffered-file->buffer) + 9755 (clear-stream _test-output-stream) + 9756 (clear-stream $_test-output-buffered-file->buffer) + 9757 # + 9758 (write _test-input-stream "type t {\n") # each t is 8 bytes, which is a power of 2 + 9759 (write _test-input-stream " x: int\n") + 9760 (write _test-input-stream " y: int\n") + 9761 (write _test-input-stream " z: int\n") + 9762 (write _test-input-stream "}\n") 9763 (write _test-input-stream "fn foo {\n") - 9764 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") - 9765 (write _test-input-stream " var o/edi: (addr int) <- index a, 0\n") + 9764 (write _test-input-stream " var arr/eax: (addr array t) <- copy 0\n") + 9765 (write _test-input-stream " var x/ebx: int <- length arr\n") 9766 (write _test-input-stream "}\n") 9767 # convert - 9768 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9769 # registers except esp clobbered at this point - 9770 # restore ed - 9771 89/<- %edx 4/r32/esp - 9772 (flush _test-output-buffered-file) - 9773 (flush _test-error-buffered-file) - 9774 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9780 # check output - 9781 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-output-type: output should be empty") - 9782 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' does not have the right type" "F - test-index-with-wrong-output-type: error message") - 9783 # check that stop(1) was called - 9784 (check-ints-equal *(edx+4) 2 "F - test-index-with-wrong-output-type: exit status") - 9785 # don't restore from ebp - 9786 81 0/subop/add %esp 8/imm32 - 9787 # . epilogue - 9788 5d/pop-to-ebp - 9789 c3/return - 9790 - 9791 test-index-with-wrong-output-compound-type: - 9792 # . prologue - 9793 55/push-ebp - 9794 89/<- %ebp 4/r32/esp - 9795 # setup - 9796 (clear-stream _test-input-stream) - 9797 (clear-stream $_test-input-buffered-file->buffer) - 9798 (clear-stream _test-output-stream) - 9799 (clear-stream $_test-output-buffered-file->buffer) - 9800 (clear-stream _test-error-stream) - 9801 (clear-stream $_test-error-buffered-file->buffer) - 9802 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9803 68/push 0/imm32 - 9804 68/push 0/imm32 - 9805 89/<- %edx 4/r32/esp - 9806 (tailor-exit-descriptor %edx 0x10) - 9807 # - 9808 (write _test-input-stream "fn foo {\n") - 9809 (write _test-input-stream " var a/ebx: (addr array handle boolean) <- copy 0\n") - 9810 (write _test-input-stream " var o/edi: (addr handle int) <- index a, 0\n") - 9811 (write _test-input-stream "}\n") - 9812 # convert - 9813 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9814 # registers except esp clobbered at this point - 9815 # restore ed - 9816 89/<- %edx 4/r32/esp - 9817 (flush _test-output-buffered-file) - 9818 (flush _test-error-buffered-file) - 9819 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9825 # check output - 9826 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-output-compound-type: output should be empty") - 9827 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' does not have the right type" "F - test-index-with-wrong-output-compound-type: error message") - 9828 # check that stop(1) was called - 9829 (check-ints-equal *(edx+4) 2 "F - test-index-with-wrong-output-compound-type: exit status") - 9830 # don't restore from ebp - 9831 81 0/subop/add %esp 8/imm32 - 9832 # . epilogue - 9833 5d/pop-to-ebp - 9834 c3/return - 9835 - 9836 test-index-with-no-inouts: - 9837 # . prologue - 9838 55/push-ebp - 9839 89/<- %ebp 4/r32/esp - 9840 # setup - 9841 (clear-stream _test-input-stream) - 9842 (clear-stream $_test-input-buffered-file->buffer) - 9843 (clear-stream _test-output-stream) - 9844 (clear-stream $_test-output-buffered-file->buffer) - 9845 (clear-stream _test-error-stream) - 9846 (clear-stream $_test-error-buffered-file->buffer) - 9847 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9848 68/push 0/imm32 - 9849 68/push 0/imm32 - 9850 89/<- %edx 4/r32/esp - 9851 (tailor-exit-descriptor %edx 0x10) - 9852 # - 9853 (write _test-input-stream "fn foo {\n") - 9854 (write _test-input-stream " var c/ecx: (addr int) <- index\n") - 9855 (write _test-input-stream "}\n") - 9856 # convert - 9857 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9858 # registers except esp clobbered at this point - 9859 # restore ed - 9860 89/<- %edx 4/r32/esp - 9861 (flush _test-output-buffered-file) - 9862 (flush _test-error-buffered-file) - 9863 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9869 # check output - 9870 (check-stream-equal _test-output-stream "" "F - test-index-with-no-inouts: output should be empty") - 9871 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too few inouts (2 required)" "F - test-index-with-no-inouts: error message") - 9872 # check that stop(1) was called - 9873 (check-ints-equal *(edx+4) 2 "F - test-index-with-no-inouts: exit status") - 9874 # don't restore from ebp - 9875 81 0/subop/add %esp 8/imm32 - 9876 # . epilogue - 9877 5d/pop-to-ebp - 9878 c3/return - 9879 - 9880 test-index-with-too-few-inouts: - 9881 # . prologue - 9882 55/push-ebp - 9883 89/<- %ebp 4/r32/esp - 9884 # setup - 9885 (clear-stream _test-input-stream) - 9886 (clear-stream $_test-input-buffered-file->buffer) - 9887 (clear-stream _test-output-stream) - 9888 (clear-stream $_test-output-buffered-file->buffer) - 9889 (clear-stream _test-error-stream) - 9890 (clear-stream $_test-error-buffered-file->buffer) - 9891 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9892 68/push 0/imm32 - 9893 68/push 0/imm32 - 9894 89/<- %edx 4/r32/esp - 9895 (tailor-exit-descriptor %edx 0x10) - 9896 # - 9897 (write _test-input-stream "fn foo {\n") - 9898 (write _test-input-stream " var a: (array int 3)\n") - 9899 (write _test-input-stream " var c/ecx: (addr int) <- index a\n") - 9900 (write _test-input-stream "}\n") - 9901 # convert - 9902 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9903 # registers except esp clobbered at this point - 9904 # restore ed - 9905 89/<- %edx 4/r32/esp - 9906 (flush _test-output-buffered-file) - 9907 (flush _test-error-buffered-file) - 9908 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9914 # check output - 9915 (check-stream-equal _test-output-stream "" "F - test-index-with-too-few-inouts: output should be empty") - 9916 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too few inouts (2 required)" "F - test-index-with-too-few-inouts: error message") - 9917 # check that stop(1) was called - 9918 (check-ints-equal *(edx+4) 2 "F - test-index-with-too-few-inouts: exit status") - 9919 # don't restore from ebp - 9920 81 0/subop/add %esp 8/imm32 - 9921 # . epilogue - 9922 5d/pop-to-ebp - 9923 c3/return - 9924 - 9925 test-index-with-too-many-inouts: - 9926 # . prologue - 9927 55/push-ebp - 9928 89/<- %ebp 4/r32/esp - 9929 # setup - 9930 (clear-stream _test-input-stream) - 9931 (clear-stream $_test-input-buffered-file->buffer) - 9932 (clear-stream _test-output-stream) - 9933 (clear-stream $_test-output-buffered-file->buffer) - 9934 (clear-stream _test-error-stream) - 9935 (clear-stream $_test-error-buffered-file->buffer) - 9936 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9937 68/push 0/imm32 - 9938 68/push 0/imm32 - 9939 89/<- %edx 4/r32/esp - 9940 (tailor-exit-descriptor %edx 0x10) - 9941 # - 9942 (write _test-input-stream "fn foo {\n") - 9943 (write _test-input-stream " var a: (array int 3)\n") - 9944 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0, 0\n") - 9945 (write _test-input-stream "}\n") - 9946 # convert - 9947 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9948 # registers except esp clobbered at this point - 9949 # restore ed - 9950 89/<- %edx 4/r32/esp - 9951 (flush _test-output-buffered-file) - 9952 (flush _test-error-buffered-file) - 9953 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 9959 # check output - 9960 (check-stream-equal _test-output-stream "" "F - test-index-with-too-many-inouts: output should be empty") - 9961 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too many inouts (2 required)" "F - test-index-with-too-many-inouts: error message") - 9962 # check that stop(1) was called - 9963 (check-ints-equal *(edx+4) 2 "F - test-index-with-too-many-inouts: exit status") - 9964 # don't restore from ebp - 9965 81 0/subop/add %esp 8/imm32 - 9966 # . epilogue - 9967 5d/pop-to-ebp - 9968 c3/return - 9969 - 9970 test-index-with-no-output: - 9971 # . prologue - 9972 55/push-ebp - 9973 89/<- %ebp 4/r32/esp - 9974 # setup - 9975 (clear-stream _test-input-stream) - 9976 (clear-stream $_test-input-buffered-file->buffer) - 9977 (clear-stream _test-output-stream) - 9978 (clear-stream $_test-output-buffered-file->buffer) - 9979 (clear-stream _test-error-stream) - 9980 (clear-stream $_test-error-buffered-file->buffer) - 9981 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) - 9982 68/push 0/imm32 - 9983 68/push 0/imm32 - 9984 89/<- %edx 4/r32/esp - 9985 (tailor-exit-descriptor %edx 0x10) - 9986 # - 9987 (write _test-input-stream "fn foo {\n") - 9988 (write _test-input-stream " var a: (array int 3)\n") - 9989 (write _test-input-stream " index a, 0\n") - 9990 (write _test-input-stream "}\n") - 9991 # convert - 9992 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) - 9993 # registers except esp clobbered at this point - 9994 # restore ed - 9995 89/<- %edx 4/r32/esp - 9996 (flush _test-output-buffered-file) - 9997 (flush _test-error-buffered-file) - 9998 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10004 # check output -10005 (check-stream-equal _test-output-stream "" "F - test-index-with-no-output: output should be empty") -10006 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: must have an output" "F - test-index-with-no-output: error message") -10007 # check that stop(1) was called -10008 (check-ints-equal *(edx+4) 2 "F - test-index-with-no-output: exit status") -10009 # don't restore from ebp -10010 81 0/subop/add %esp 8/imm32 -10011 # . epilogue -10012 5d/pop-to-ebp -10013 c3/return -10014 -10015 test-index-with-too-many-outputs: -10016 # . prologue -10017 55/push-ebp -10018 89/<- %ebp 4/r32/esp -10019 # setup -10020 (clear-stream _test-input-stream) -10021 (clear-stream $_test-input-buffered-file->buffer) -10022 (clear-stream _test-output-stream) -10023 (clear-stream $_test-output-buffered-file->buffer) -10024 (clear-stream _test-error-stream) -10025 (clear-stream $_test-error-buffered-file->buffer) -10026 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10027 68/push 0/imm32 -10028 68/push 0/imm32 -10029 89/<- %edx 4/r32/esp -10030 (tailor-exit-descriptor %edx 0x10) -10031 # -10032 (write _test-input-stream "fn foo {\n") -10033 (write _test-input-stream " var a: (array int 3)\n") -10034 (write _test-input-stream " var b/eax: (addr int) <- copy 0\n") -10035 (write _test-input-stream " var c/ecx: (addr int) <- copy 0\n") -10036 (write _test-input-stream " b, c <- index a, 0\n") -10037 (write _test-input-stream "}\n") -10038 # convert -10039 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10040 # registers except esp clobbered at this point -10041 # restore ed -10042 89/<- %edx 4/r32/esp -10043 (flush _test-output-buffered-file) -10044 (flush _test-error-buffered-file) -10045 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10051 # check output -10052 (check-stream-equal _test-output-stream "" "F - test-index-with-too-many-outputs: output should be empty") -10053 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too many outputs (1 required)" "F - test-index-with-too-many-outputs: error message") -10054 # check that stop(1) was called -10055 (check-ints-equal *(edx+4) 2 "F - test-index-with-too-many-outputs: exit status") -10056 # don't restore from ebp -10057 81 0/subop/add %esp 8/imm32 -10058 # . epilogue -10059 5d/pop-to-ebp -10060 c3/return -10061 -10062 test-compute-offset-with-non-array-atom-base-type: -10063 # . prologue -10064 55/push-ebp -10065 89/<- %ebp 4/r32/esp -10066 # setup -10067 (clear-stream _test-input-stream) -10068 (clear-stream $_test-input-buffered-file->buffer) -10069 (clear-stream _test-output-stream) -10070 (clear-stream $_test-output-buffered-file->buffer) -10071 (clear-stream _test-error-stream) -10072 (clear-stream $_test-error-buffered-file->buffer) -10073 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10074 68/push 0/imm32 -10075 68/push 0/imm32 -10076 89/<- %edx 4/r32/esp -10077 (tailor-exit-descriptor %edx 0x10) -10078 # -10079 (write _test-input-stream "fn foo {\n") -10080 (write _test-input-stream " var a: int\n") -10081 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n") -10082 (write _test-input-stream "}\n") -10083 # convert -10084 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10085 # registers except esp clobbered at this point -10086 # restore ed -10087 89/<- %edx 4/r32/esp -10088 (flush _test-output-buffered-file) -10089 (flush _test-error-buffered-file) -10090 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10096 # check output -10097 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-non-array-atom-base-type: output should be empty") -10098 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: var 'a' is not an array" "F - test-compute-offset-with-non-array-atom-base-type: error message") -10099 # check that stop(1) was called -10100 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-non-array-atom-base-type: exit status") -10101 # don't restore from ebp -10102 81 0/subop/add %esp 8/imm32 -10103 # . epilogue -10104 5d/pop-to-ebp -10105 c3/return -10106 -10107 test-compute-offset-with-non-array-compound-base-type: -10108 # . prologue -10109 55/push-ebp -10110 89/<- %ebp 4/r32/esp -10111 # setup -10112 (clear-stream _test-input-stream) -10113 (clear-stream $_test-input-buffered-file->buffer) -10114 (clear-stream _test-output-stream) -10115 (clear-stream $_test-output-buffered-file->buffer) -10116 (clear-stream _test-error-stream) -10117 (clear-stream $_test-error-buffered-file->buffer) -10118 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10119 68/push 0/imm32 -10120 68/push 0/imm32 -10121 89/<- %edx 4/r32/esp -10122 (tailor-exit-descriptor %edx 0x10) -10123 # -10124 (write _test-input-stream "fn foo {\n") -10125 (write _test-input-stream " var a: (handle int)\n") -10126 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n") -10127 (write _test-input-stream "}\n") -10128 # convert -10129 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10130 # registers except esp clobbered at this point -10131 # restore ed -10132 89/<- %edx 4/r32/esp -10133 (flush _test-output-buffered-file) -10134 (flush _test-error-buffered-file) -10135 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10141 # check output -10142 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-non-array-compound-base-type: output should be empty") -10143 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: var 'a' is not an array" "F - test-compute-offset-with-non-array-compound-base-type: error message") -10144 # check that stop(1) was called -10145 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-non-array-compound-base-type: exit status") -10146 # don't restore from ebp -10147 81 0/subop/add %esp 8/imm32 -10148 # . epilogue -10149 5d/pop-to-ebp -10150 c3/return -10151 -10152 test-compute-offset-with-non-array-compound-base-type-2: -10153 # . prologue -10154 55/push-ebp -10155 89/<- %ebp 4/r32/esp -10156 # setup -10157 (clear-stream _test-input-stream) -10158 (clear-stream $_test-input-buffered-file->buffer) -10159 (clear-stream _test-output-stream) -10160 (clear-stream $_test-output-buffered-file->buffer) -10161 (clear-stream _test-error-stream) -10162 (clear-stream $_test-error-buffered-file->buffer) -10163 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10164 68/push 0/imm32 -10165 68/push 0/imm32 -10166 89/<- %edx 4/r32/esp -10167 (tailor-exit-descriptor %edx 0x10) -10168 # -10169 (write _test-input-stream "fn foo {\n") -10170 (write _test-input-stream " var a: (addr int)\n") -10171 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n") -10172 (write _test-input-stream "}\n") -10173 # convert -10174 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10175 # registers except esp clobbered at this point -10176 # restore ed -10177 89/<- %edx 4/r32/esp -10178 (flush _test-output-buffered-file) -10179 (flush _test-error-buffered-file) -10180 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10186 # check output -10187 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-non-array-compound-base-type-2: output should be empty") -10188 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: var 'a' is not an array" "F - test-compute-offset-with-non-array-compound-base-type-2: error message") -10189 # check that stop(1) was called -10190 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-non-array-compound-base-type-2: exit status") -10191 # don't restore from ebp -10192 81 0/subop/add %esp 8/imm32 -10193 # . epilogue -10194 5d/pop-to-ebp -10195 c3/return -10196 -10197 test-compute-offset-with-array-atom-base-type: -10198 # . prologue -10199 55/push-ebp -10200 89/<- %ebp 4/r32/esp -10201 # setup -10202 (clear-stream _test-input-stream) -10203 (clear-stream $_test-input-buffered-file->buffer) -10204 (clear-stream _test-output-stream) -10205 (clear-stream $_test-output-buffered-file->buffer) -10206 (clear-stream _test-error-stream) -10207 (clear-stream $_test-error-buffered-file->buffer) -10208 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10209 68/push 0/imm32 -10210 68/push 0/imm32 -10211 89/<- %edx 4/r32/esp -10212 (tailor-exit-descriptor %edx 0x10) -10213 # -10214 (write _test-input-stream "fn foo {\n") -10215 (write _test-input-stream " var a: array\n") -10216 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n") -10217 (write _test-input-stream "}\n") -10218 # convert -10219 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10220 # registers except esp clobbered at this point -10221 # restore ed -10222 89/<- %edx 4/r32/esp -10223 (flush _test-output-buffered-file) -10224 (flush _test-error-buffered-file) -10225 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10231 # check output -10232 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-array-atom-base-type: output should be empty") -10233 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: array 'a' must specify the type of its elements" "F - test-compute-offset-with-array-atom-base-type: error message") -10234 # check that stop(1) was called -10235 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-array-atom-base-type: exit status") -10236 # don't restore from ebp -10237 81 0/subop/add %esp 8/imm32 -10238 # . epilogue -10239 5d/pop-to-ebp -10240 c3/return -10241 -10242 test-compute-offset-with-wrong-index-type: -10243 # . prologue -10244 55/push-ebp -10245 89/<- %ebp 4/r32/esp -10246 # setup -10247 (clear-stream _test-input-stream) -10248 (clear-stream $_test-input-buffered-file->buffer) -10249 (clear-stream _test-output-stream) -10250 (clear-stream $_test-output-buffered-file->buffer) -10251 (clear-stream _test-error-stream) -10252 (clear-stream $_test-error-buffered-file->buffer) -10253 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10254 68/push 0/imm32 -10255 68/push 0/imm32 -10256 89/<- %edx 4/r32/esp -10257 (tailor-exit-descriptor %edx 0x10) -10258 # -10259 (write _test-input-stream "fn foo {\n") -10260 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n") -10261 (write _test-input-stream " var b: boolean\n") -10262 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, b\n") -10263 (write _test-input-stream "}\n") -10264 # convert -10265 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10266 # registers except esp clobbered at this point -10267 # restore ed -10268 89/<- %edx 4/r32/esp -10269 (flush _test-output-buffered-file) -10270 (flush _test-error-buffered-file) -10271 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10277 # check output -10278 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-wrong-index-type: output should be empty") -10279 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: second argument 'b' must be an int" "F - test-compute-offset-with-wrong-index-type: error message") -10280 # check that stop(1) was called -10281 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-wrong-index-type: exit status") -10282 # don't restore from ebp -10283 81 0/subop/add %esp 8/imm32 -10284 # . epilogue -10285 5d/pop-to-ebp -10286 c3/return -10287 -10288 test-compute-offset-with-output-not-offset: -10289 # . prologue -10290 55/push-ebp -10291 89/<- %ebp 4/r32/esp -10292 # setup -10293 (clear-stream _test-input-stream) -10294 (clear-stream $_test-input-buffered-file->buffer) -10295 (clear-stream _test-output-stream) -10296 (clear-stream $_test-output-buffered-file->buffer) -10297 (clear-stream _test-error-stream) -10298 (clear-stream $_test-error-buffered-file->buffer) -10299 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10300 68/push 0/imm32 -10301 68/push 0/imm32 -10302 89/<- %edx 4/r32/esp -10303 (tailor-exit-descriptor %edx 0x10) -10304 # -10305 (write _test-input-stream "fn foo {\n") -10306 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") -10307 (write _test-input-stream " var o/edi: int <- compute-offset a, 0\n") -10308 (write _test-input-stream "}\n") -10309 # convert -10310 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10311 # registers except esp clobbered at this point -10312 # restore ed -10313 89/<- %edx 4/r32/esp -10314 (flush _test-output-buffered-file) -10315 (flush _test-error-buffered-file) -10316 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10322 # check output -10323 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-output-not-offset: output should be empty") -10324 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' must be an offset" "F - test-compute-offset-with-output-not-offset: error message") -10325 # check that stop(1) was called -10326 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-output-not-offset: exit status") -10327 # don't restore from ebp -10328 81 0/subop/add %esp 8/imm32 -10329 # . epilogue -10330 5d/pop-to-ebp -10331 c3/return -10332 -10333 test-compute-offset-with-output-not-address-2: -10334 # . prologue -10335 55/push-ebp -10336 89/<- %ebp 4/r32/esp -10337 # setup -10338 (clear-stream _test-input-stream) -10339 (clear-stream $_test-input-buffered-file->buffer) -10340 (clear-stream _test-output-stream) -10341 (clear-stream $_test-output-buffered-file->buffer) -10342 (clear-stream _test-error-stream) -10343 (clear-stream $_test-error-buffered-file->buffer) -10344 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10345 68/push 0/imm32 -10346 68/push 0/imm32 -10347 89/<- %edx 4/r32/esp -10348 (tailor-exit-descriptor %edx 0x10) -10349 # -10350 (write _test-input-stream "fn foo {\n") -10351 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") -10352 (write _test-input-stream " var o/edi: (int) <- compute-offset a, 0\n") -10353 (write _test-input-stream "}\n") -10354 # convert -10355 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10356 # registers except esp clobbered at this point -10357 # restore ed -10358 89/<- %edx 4/r32/esp -10359 (flush _test-output-buffered-file) -10360 (flush _test-error-buffered-file) -10361 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10367 # check output -10368 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-output-not-address-2: output should be empty") -10369 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' must be an offset" "F - test-compute-offset-with-output-not-address-2: error message") -10370 # check that stop(1) was called -10371 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-output-not-address-2: exit status") -10372 # don't restore from ebp -10373 81 0/subop/add %esp 8/imm32 -10374 # . epilogue -10375 5d/pop-to-ebp -10376 c3/return -10377 -10378 test-compute-offset-with-wrong-output-type: -10379 # . prologue -10380 55/push-ebp -10381 89/<- %ebp 4/r32/esp -10382 # setup -10383 (clear-stream _test-input-stream) -10384 (clear-stream $_test-input-buffered-file->buffer) -10385 (clear-stream _test-output-stream) -10386 (clear-stream $_test-output-buffered-file->buffer) -10387 (clear-stream _test-error-stream) -10388 (clear-stream $_test-error-buffered-file->buffer) -10389 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10390 68/push 0/imm32 -10391 68/push 0/imm32 -10392 89/<- %edx 4/r32/esp -10393 (tailor-exit-descriptor %edx 0x10) -10394 # -10395 (write _test-input-stream "fn foo {\n") -10396 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") -10397 (write _test-input-stream " var o/edi: (offset int) <- compute-offset a, 0\n") -10398 (write _test-input-stream "}\n") -10399 # convert -10400 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10401 # registers except esp clobbered at this point -10402 # restore ed -10403 89/<- %edx 4/r32/esp -10404 (flush _test-output-buffered-file) -10405 (flush _test-error-buffered-file) -10406 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10412 # check output -10413 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-wrong-output-type: output should be empty") -10414 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' does not have the right type" "F - test-compute-offset-with-wrong-output-type: error message") -10415 # check that stop(1) was called -10416 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-wrong-output-type: exit status") -10417 # don't restore from ebp -10418 81 0/subop/add %esp 8/imm32 -10419 # . epilogue -10420 5d/pop-to-ebp -10421 c3/return -10422 -10423 test-compute-offset-with-wrong-output-compound-type: -10424 # . prologue -10425 55/push-ebp -10426 89/<- %ebp 4/r32/esp -10427 # setup -10428 (clear-stream _test-input-stream) -10429 (clear-stream $_test-input-buffered-file->buffer) -10430 (clear-stream _test-output-stream) -10431 (clear-stream $_test-output-buffered-file->buffer) -10432 (clear-stream _test-error-stream) -10433 (clear-stream $_test-error-buffered-file->buffer) -10434 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10435 68/push 0/imm32 -10436 68/push 0/imm32 -10437 89/<- %edx 4/r32/esp -10438 (tailor-exit-descriptor %edx 0x10) -10439 # -10440 (write _test-input-stream "fn foo {\n") -10441 (write _test-input-stream " var a/ebx: (addr array handle boolean) <- copy 0\n") -10442 (write _test-input-stream " var o/edi: (offset handle int) <- compute-offset a, 0\n") -10443 (write _test-input-stream "}\n") -10444 # convert -10445 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10446 # registers except esp clobbered at this point -10447 # restore ed -10448 89/<- %edx 4/r32/esp -10449 (flush _test-output-buffered-file) -10450 (flush _test-error-buffered-file) -10451 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10457 # check output -10458 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-wrong-output-compound-type: output should be empty") -10459 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' does not have the right type" "F - test-compute-offset-with-wrong-output-compound-type: error message") -10460 # check that stop(1) was called -10461 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-wrong-output-compound-type: exit status") -10462 # don't restore from ebp -10463 81 0/subop/add %esp 8/imm32 -10464 # . epilogue -10465 5d/pop-to-ebp -10466 c3/return -10467 -10468 test-compute-offset-with-no-inouts: -10469 # . prologue -10470 55/push-ebp -10471 89/<- %ebp 4/r32/esp -10472 # setup -10473 (clear-stream _test-input-stream) -10474 (clear-stream $_test-input-buffered-file->buffer) -10475 (clear-stream _test-output-stream) -10476 (clear-stream $_test-output-buffered-file->buffer) -10477 (clear-stream _test-error-stream) -10478 (clear-stream $_test-error-buffered-file->buffer) -10479 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10480 68/push 0/imm32 -10481 68/push 0/imm32 -10482 89/<- %edx 4/r32/esp -10483 (tailor-exit-descriptor %edx 0x10) -10484 # -10485 (write _test-input-stream "fn foo {\n") -10486 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset\n") -10487 (write _test-input-stream "}\n") -10488 # convert -10489 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10490 # registers except esp clobbered at this point -10491 # restore ed -10492 89/<- %edx 4/r32/esp -10493 (flush _test-output-buffered-file) -10494 (flush _test-error-buffered-file) -10495 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10501 # check output -10502 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-no-inouts: output should be empty") -10503 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too few inouts (2 required)" "F - test-compute-offset-with-no-inouts: error message") -10504 # check that stop(1) was called -10505 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-no-inouts: exit status") -10506 # don't restore from ebp -10507 81 0/subop/add %esp 8/imm32 -10508 # . epilogue -10509 5d/pop-to-ebp -10510 c3/return -10511 -10512 test-compute-offset-with-too-few-inouts: -10513 # . prologue -10514 55/push-ebp -10515 89/<- %ebp 4/r32/esp -10516 # setup -10517 (clear-stream _test-input-stream) -10518 (clear-stream $_test-input-buffered-file->buffer) -10519 (clear-stream _test-output-stream) -10520 (clear-stream $_test-output-buffered-file->buffer) -10521 (clear-stream _test-error-stream) -10522 (clear-stream $_test-error-buffered-file->buffer) -10523 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10524 68/push 0/imm32 -10525 68/push 0/imm32 -10526 89/<- %edx 4/r32/esp -10527 (tailor-exit-descriptor %edx 0x10) -10528 # -10529 (write _test-input-stream "fn foo {\n") -10530 (write _test-input-stream " var a: (array int 3)\n") -10531 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a\n") -10532 (write _test-input-stream "}\n") -10533 # convert -10534 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10535 # registers except esp clobbered at this point -10536 # restore ed -10537 89/<- %edx 4/r32/esp -10538 (flush _test-output-buffered-file) -10539 (flush _test-error-buffered-file) -10540 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10546 # check output -10547 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-too-few-inouts: output should be empty") -10548 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too few inouts (2 required)" "F - test-compute-offset-with-too-few-inouts: error message") -10549 # check that stop(1) was called -10550 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-too-few-inouts: exit status") -10551 # don't restore from ebp -10552 81 0/subop/add %esp 8/imm32 -10553 # . epilogue -10554 5d/pop-to-ebp -10555 c3/return -10556 -10557 test-compute-offset-with-too-many-inouts: -10558 # . prologue -10559 55/push-ebp -10560 89/<- %ebp 4/r32/esp -10561 # setup -10562 (clear-stream _test-input-stream) -10563 (clear-stream $_test-input-buffered-file->buffer) -10564 (clear-stream _test-output-stream) -10565 (clear-stream $_test-output-buffered-file->buffer) -10566 (clear-stream _test-error-stream) -10567 (clear-stream $_test-error-buffered-file->buffer) -10568 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10569 68/push 0/imm32 -10570 68/push 0/imm32 -10571 89/<- %edx 4/r32/esp -10572 (tailor-exit-descriptor %edx 0x10) -10573 # -10574 (write _test-input-stream "fn foo {\n") -10575 (write _test-input-stream " var a: (array int 3)\n") -10576 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0, 0\n") -10577 (write _test-input-stream "}\n") -10578 # convert -10579 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10580 # registers except esp clobbered at this point -10581 # restore ed -10582 89/<- %edx 4/r32/esp -10583 (flush _test-output-buffered-file) -10584 (flush _test-error-buffered-file) -10585 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10591 # check output -10592 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-too-many-inouts: output should be empty") -10593 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too many inouts (2 required)" "F - test-compute-offset-with-too-many-inouts: error message") -10594 # check that stop(1) was called -10595 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-too-many-inouts: exit status") -10596 # don't restore from ebp -10597 81 0/subop/add %esp 8/imm32 -10598 # . epilogue -10599 5d/pop-to-ebp -10600 c3/return -10601 -10602 test-compute-offset-with-no-output: -10603 # . prologue -10604 55/push-ebp -10605 89/<- %ebp 4/r32/esp -10606 # setup -10607 (clear-stream _test-input-stream) -10608 (clear-stream $_test-input-buffered-file->buffer) -10609 (clear-stream _test-output-stream) -10610 (clear-stream $_test-output-buffered-file->buffer) -10611 (clear-stream _test-error-stream) -10612 (clear-stream $_test-error-buffered-file->buffer) -10613 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10614 68/push 0/imm32 -10615 68/push 0/imm32 -10616 89/<- %edx 4/r32/esp -10617 (tailor-exit-descriptor %edx 0x10) -10618 # -10619 (write _test-input-stream "fn foo {\n") -10620 (write _test-input-stream " var a: (array int 3)\n") -10621 (write _test-input-stream " compute-offset a, 0\n") -10622 (write _test-input-stream "}\n") -10623 # convert -10624 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10625 # registers except esp clobbered at this point -10626 # restore ed -10627 89/<- %edx 4/r32/esp -10628 (flush _test-output-buffered-file) -10629 (flush _test-error-buffered-file) -10630 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10636 # check output -10637 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-no-output: output should be empty") -10638 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: must have an output" "F - test-compute-offset-with-no-output: error message") -10639 # check that stop(1) was called -10640 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-no-output: exit status") -10641 # don't restore from ebp -10642 81 0/subop/add %esp 8/imm32 -10643 # . epilogue -10644 5d/pop-to-ebp -10645 c3/return -10646 -10647 test-compute-offset-with-too-many-outputs: -10648 # . prologue -10649 55/push-ebp -10650 89/<- %ebp 4/r32/esp -10651 # setup -10652 (clear-stream _test-input-stream) -10653 (clear-stream $_test-input-buffered-file->buffer) -10654 (clear-stream _test-output-stream) -10655 (clear-stream $_test-output-buffered-file->buffer) -10656 (clear-stream _test-error-stream) -10657 (clear-stream $_test-error-buffered-file->buffer) -10658 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10659 68/push 0/imm32 -10660 68/push 0/imm32 -10661 89/<- %edx 4/r32/esp -10662 (tailor-exit-descriptor %edx 0x10) -10663 # -10664 (write _test-input-stream "fn foo {\n") -10665 (write _test-input-stream " var a: (array int 3)\n") -10666 (write _test-input-stream " var b/eax: (offset int) <- compute-offset a, 0\n") -10667 (write _test-input-stream " var c/ecx: (addr int) <- copy 0\n") -10668 (write _test-input-stream " b, c <- compute-offset a, 0\n") -10669 (write _test-input-stream "}\n") -10670 # convert -10671 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10672 # registers except esp clobbered at this point -10673 # restore ed -10674 89/<- %edx 4/r32/esp -10675 (flush _test-output-buffered-file) -10676 (flush _test-error-buffered-file) -10677 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10683 # check output -10684 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-too-many-outputs: output should be empty") -10685 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too many outputs (1 required)" "F - test-compute-offset-with-too-many-outputs: error message") -10686 # check that stop(1) was called -10687 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-too-many-outputs: exit status") -10688 # don't restore from ebp -10689 81 0/subop/add %esp 8/imm32 -10690 # . epilogue -10691 5d/pop-to-ebp -10692 c3/return -10693 -10694 test-convert-read-from-stream: -10695 # . prologue -10696 55/push-ebp -10697 89/<- %ebp 4/r32/esp -10698 # setup -10699 (clear-stream _test-input-stream) -10700 (clear-stream $_test-input-buffered-file->buffer) -10701 (clear-stream _test-output-stream) -10702 (clear-stream $_test-output-buffered-file->buffer) -10703 # -10704 (write _test-input-stream "fn foo {\n") -10705 (write _test-input-stream " var s/esi: (addr stream int) <- copy 0\n") -10706 (write _test-input-stream " var o/ecx: (addr int) <- copy 0\n") -10707 (write _test-input-stream " read-from-stream s, o\n") -10708 (write _test-input-stream "}\n") -10709 # convert -10710 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -10711 # registers except esp clobbered at this point -10712 # restore ed -10713 89/<- %edx 4/r32/esp -10714 (flush _test-output-buffered-file) -10715 (flush _test-error-buffered-file) -10716 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10722 # check output -10723 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-read-from-stream/0") -10724 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-read-from-stream/1") -10725 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-read-from-stream/2") -10726 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-read-from-stream/3") -10727 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-read-from-stream/4") -10728 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-read-from-stream/5") -10729 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-read-from-stream/6") -10730 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-read-from-stream/7") -10731 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-read-from-stream/8") -10732 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-read-from-stream/9") -10733 (check-next-stream-line-equal _test-output-stream " (read-from-stream %esi %ecx 0x00000004)" "F - test-convert-read-from-stream/10") -10734 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-read-from-stream/11") -10735 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-read-from-stream/12") -10736 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-read-from-stream/13") -10737 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-read-from-stream/14") -10738 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-read-from-stream/15") -10739 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-read-from-stream/16") -10740 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-read-from-stream/17") -10741 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-read-from-stream/18") -10742 # . epilogue -10743 89/<- %esp 5/r32/ebp -10744 5d/pop-to-ebp -10745 c3/return -10746 -10747 test-convert-read-from-stream-with-correct-payload-size: -10748 # . prologue -10749 55/push-ebp -10750 89/<- %ebp 4/r32/esp -10751 # setup -10752 (clear-stream _test-input-stream) -10753 (clear-stream $_test-input-buffered-file->buffer) -10754 (clear-stream _test-output-stream) -10755 (clear-stream $_test-output-buffered-file->buffer) -10756 # -10757 (write _test-input-stream "fn foo {\n") -10758 (write _test-input-stream " var s/esi: (addr stream handle int) <- copy 0\n") -10759 (write _test-input-stream " var o/ecx: (addr handle int) <- copy 0\n") -10760 (write _test-input-stream " read-from-stream s, o\n") -10761 (write _test-input-stream "}\n") -10762 # convert -10763 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -10764 # registers except esp clobbered at this point -10765 # restore ed -10766 89/<- %edx 4/r32/esp -10767 (flush _test-output-buffered-file) -10768 (flush _test-error-buffered-file) -10769 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10775 # check output -10776 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-read-from-stream-with-correct-payload-size/0") -10777 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-read-from-stream-with-correct-payload-size/1") -10778 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-read-from-stream-with-correct-payload-size/2") -10779 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-read-from-stream-with-correct-payload-size/3") -10780 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-read-from-stream-with-correct-payload-size/4") -10781 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-read-from-stream-with-correct-payload-size/5") -10782 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-read-from-stream-with-correct-payload-size/6") -10783 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-read-from-stream-with-correct-payload-size/7") -10784 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-read-from-stream-with-correct-payload-size/8") -10785 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-read-from-stream-with-correct-payload-size/9") -10786 (check-next-stream-line-equal _test-output-stream " (read-from-stream %esi %ecx 0x00000008)" "F - test-convert-read-from-stream-with-correct-payload-size/10") -10787 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-read-from-stream-with-correct-payload-size/11") -10788 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-read-from-stream-with-correct-payload-size/12") -10789 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-read-from-stream-with-correct-payload-size/13") -10790 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-read-from-stream-with-correct-payload-size/14") -10791 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-read-from-stream-with-correct-payload-size/15") -10792 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-read-from-stream-with-correct-payload-size/16") -10793 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-read-from-stream-with-correct-payload-size/17") -10794 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-read-from-stream-with-correct-payload-size/18") -10795 # . epilogue -10796 89/<- %esp 5/r32/ebp -10797 5d/pop-to-ebp -10798 c3/return -10799 -10800 test-read-from-stream-with-non-stream-atom-base-type: -10801 # . prologue -10802 55/push-ebp -10803 89/<- %ebp 4/r32/esp -10804 # setup -10805 (clear-stream _test-input-stream) -10806 (clear-stream $_test-input-buffered-file->buffer) -10807 (clear-stream _test-output-stream) -10808 (clear-stream $_test-output-buffered-file->buffer) -10809 (clear-stream _test-error-stream) -10810 (clear-stream $_test-error-buffered-file->buffer) -10811 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10812 68/push 0/imm32 -10813 68/push 0/imm32 -10814 89/<- %edx 4/r32/esp -10815 (tailor-exit-descriptor %edx 0x10) -10816 # -10817 (write _test-input-stream "fn foo {\n") -10818 (write _test-input-stream " var a: int\n") -10819 (write _test-input-stream " read-from-stream a, 0\n") -10820 (write _test-input-stream "}\n") -10821 # convert -10822 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10823 # registers except esp clobbered at this point -10824 # restore ed -10825 89/<- %edx 4/r32/esp -10826 (flush _test-output-buffered-file) -10827 (flush _test-error-buffered-file) -10828 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10834 # check output -10835 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-non-stream-atom-base-type: output should be empty") -10836 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-non-stream-atom-base-type: error message") -10837 # check that stop(1) was called -10838 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-non-stream-atom-base-type: exit status") -10839 # don't restore from ebp -10840 81 0/subop/add %esp 8/imm32 -10841 # . epilogue -10842 5d/pop-to-ebp -10843 c3/return -10844 -10845 test-read-from-stream-with-non-stream-compound-base-type: -10846 # . prologue -10847 55/push-ebp -10848 89/<- %ebp 4/r32/esp -10849 # setup -10850 (clear-stream _test-input-stream) -10851 (clear-stream $_test-input-buffered-file->buffer) -10852 (clear-stream _test-output-stream) -10853 (clear-stream $_test-output-buffered-file->buffer) -10854 (clear-stream _test-error-stream) -10855 (clear-stream $_test-error-buffered-file->buffer) -10856 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10857 68/push 0/imm32 -10858 68/push 0/imm32 -10859 89/<- %edx 4/r32/esp -10860 (tailor-exit-descriptor %edx 0x10) -10861 # -10862 (write _test-input-stream "fn foo {\n") -10863 (write _test-input-stream " var a: (handle int)\n") -10864 (write _test-input-stream " read-from-stream a, 0\n") -10865 (write _test-input-stream "}\n") -10866 # convert -10867 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10868 # registers except esp clobbered at this point -10869 # restore ed + 9768 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) + 9769 (flush _test-output-buffered-file) + 9770 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9776 # check output + 9777 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-length-of-array-of-user-defined-types/0") + 9778 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-length-of-array-of-user-defined-types/1") + 9779 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-length-of-array-of-user-defined-types/2") + 9780 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-length-of-array-of-user-defined-types/3") + 9781 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-length-of-array-of-user-defined-types/4") + 9782 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-length-of-array-of-user-defined-types/5") + 9783 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-length-of-array-of-user-defined-types/6") + 9784 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 0/imm32" "F - test-convert-length-of-array-of-user-defined-types/7") + 9785 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ebx" "F - test-convert-length-of-array-of-user-defined-types/8") + 9786 (check-next-stream-line-equal _test-output-stream " 50/push-eax" "F - test-convert-length-of-array-of-user-defined-types/9") + 9787 (check-next-stream-line-equal _test-output-stream " 51/push-ecx" "F - test-convert-length-of-array-of-user-defined-types/10") + 9788 (check-next-stream-line-equal _test-output-stream " 52/push-edx" "F - test-convert-length-of-array-of-user-defined-types/11") + 9789 (check-next-stream-line-equal _test-output-stream " 8b/-> *eax 0x00000000/r32" "F - test-convert-length-of-array-of-user-defined-types/12") + 9790 (check-next-stream-line-equal _test-output-stream " 31/xor %edx 2/r32/edx" "F - test-convert-length-of-array-of-user-defined-types/13") + 9791 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0x0000000c/imm32" "F - test-convert-length-of-array-of-user-defined-types/14") + 9792 (check-next-stream-line-equal _test-output-stream " f7 7/subop/idiv-eax-edx-by %ecx" "F - test-convert-length-of-array-of-user-defined-types/15") + 9793 (check-next-stream-line-equal _test-output-stream " 89/<- %ebx 0/r32/eax" "F - test-convert-length-of-array-of-user-defined-types/16") + 9794 (check-next-stream-line-equal _test-output-stream " 5a/pop-to-edx" "F - test-convert-length-of-array-of-user-defined-types/17") + 9795 (check-next-stream-line-equal _test-output-stream " 59/pop-to-ecx" "F - test-convert-length-of-array-of-user-defined-types/18") + 9796 (check-next-stream-line-equal _test-output-stream " 58/pop-to-eax" "F - test-convert-length-of-array-of-user-defined-types/19") + 9797 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ebx" "F - test-convert-length-of-array-of-user-defined-types/20") + 9798 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-length-of-array-of-user-defined-types/21") + 9799 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-length-of-array-of-user-defined-types/22") + 9800 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-length-of-array-of-user-defined-types/23") + 9801 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-length-of-array-of-user-defined-types/24") + 9802 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-length-of-array-of-user-defined-types/25") + 9803 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-length-of-array-of-user-defined-types/26") + 9804 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-length-of-array-of-user-defined-types/27") + 9805 # . epilogue + 9806 89/<- %esp 5/r32/ebp + 9807 5d/pop-to-ebp + 9808 c3/return + 9809 + 9810 test-index-with-non-array-atom-base-type: + 9811 # . prologue + 9812 55/push-ebp + 9813 89/<- %ebp 4/r32/esp + 9814 # setup + 9815 (clear-stream _test-input-stream) + 9816 (clear-stream $_test-input-buffered-file->buffer) + 9817 (clear-stream _test-output-stream) + 9818 (clear-stream $_test-output-buffered-file->buffer) + 9819 (clear-stream _test-error-stream) + 9820 (clear-stream $_test-error-buffered-file->buffer) + 9821 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9822 68/push 0/imm32 + 9823 68/push 0/imm32 + 9824 89/<- %edx 4/r32/esp + 9825 (tailor-exit-descriptor %edx 0x10) + 9826 # + 9827 (write _test-input-stream "fn foo {\n") + 9828 (write _test-input-stream " var a: int\n") + 9829 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") + 9830 (write _test-input-stream "}\n") + 9831 # convert + 9832 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9833 # registers except esp clobbered at this point + 9834 # restore ed + 9835 89/<- %edx 4/r32/esp + 9836 (flush _test-output-buffered-file) + 9837 (flush _test-error-buffered-file) + 9838 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9844 # check output + 9845 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-atom-base-type: output should be empty") + 9846 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-atom-base-type: error message") + 9847 # check that stop(1) was called + 9848 (check-ints-equal *(edx+4) 2 "F - test-index-with-non-array-atom-base-type: exit status") + 9849 # don't restore from ebp + 9850 81 0/subop/add %esp 8/imm32 + 9851 # . epilogue + 9852 5d/pop-to-ebp + 9853 c3/return + 9854 + 9855 test-index-with-non-array-compound-base-type: + 9856 # . prologue + 9857 55/push-ebp + 9858 89/<- %ebp 4/r32/esp + 9859 # setup + 9860 (clear-stream _test-input-stream) + 9861 (clear-stream $_test-input-buffered-file->buffer) + 9862 (clear-stream _test-output-stream) + 9863 (clear-stream $_test-output-buffered-file->buffer) + 9864 (clear-stream _test-error-stream) + 9865 (clear-stream $_test-error-buffered-file->buffer) + 9866 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9867 68/push 0/imm32 + 9868 68/push 0/imm32 + 9869 89/<- %edx 4/r32/esp + 9870 (tailor-exit-descriptor %edx 0x10) + 9871 # + 9872 (write _test-input-stream "fn foo {\n") + 9873 (write _test-input-stream " var a: (handle int)\n") + 9874 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") + 9875 (write _test-input-stream "}\n") + 9876 # convert + 9877 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9878 # registers except esp clobbered at this point + 9879 # restore ed + 9880 89/<- %edx 4/r32/esp + 9881 (flush _test-output-buffered-file) + 9882 (flush _test-error-buffered-file) + 9883 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9889 # check output + 9890 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-compound-base-type: output should be empty") + 9891 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-compound-base-type: error message") + 9892 # check that stop(1) was called + 9893 (check-ints-equal *(edx+4) 2 "F - test-index-with-non-array-compound-base-type: exit status") + 9894 # don't restore from ebp + 9895 81 0/subop/add %esp 8/imm32 + 9896 # . epilogue + 9897 5d/pop-to-ebp + 9898 c3/return + 9899 + 9900 test-index-with-non-array-compound-base-type-2: + 9901 # . prologue + 9902 55/push-ebp + 9903 89/<- %ebp 4/r32/esp + 9904 # setup + 9905 (clear-stream _test-input-stream) + 9906 (clear-stream $_test-input-buffered-file->buffer) + 9907 (clear-stream _test-output-stream) + 9908 (clear-stream $_test-output-buffered-file->buffer) + 9909 (clear-stream _test-error-stream) + 9910 (clear-stream $_test-error-buffered-file->buffer) + 9911 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9912 68/push 0/imm32 + 9913 68/push 0/imm32 + 9914 89/<- %edx 4/r32/esp + 9915 (tailor-exit-descriptor %edx 0x10) + 9916 # + 9917 (write _test-input-stream "fn foo {\n") + 9918 (write _test-input-stream " var a: (addr int)\n") + 9919 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") + 9920 (write _test-input-stream "}\n") + 9921 # convert + 9922 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9923 # registers except esp clobbered at this point + 9924 # restore ed + 9925 89/<- %edx 4/r32/esp + 9926 (flush _test-output-buffered-file) + 9927 (flush _test-error-buffered-file) + 9928 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9934 # check output + 9935 (check-stream-equal _test-output-stream "" "F - test-index-with-non-array-compound-base-type-2: output should be empty") + 9936 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is not an array" "F - test-index-with-non-array-compound-base-type-2: error message") + 9937 # check that stop(1) was called + 9938 (check-ints-equal *(edx+4) 2 "F - test-index-with-non-array-compound-base-type-2: exit status") + 9939 # don't restore from ebp + 9940 81 0/subop/add %esp 8/imm32 + 9941 # . epilogue + 9942 5d/pop-to-ebp + 9943 c3/return + 9944 + 9945 test-index-with-array-atom-base-type: + 9946 # . prologue + 9947 55/push-ebp + 9948 89/<- %ebp 4/r32/esp + 9949 # setup + 9950 (clear-stream _test-input-stream) + 9951 (clear-stream $_test-input-buffered-file->buffer) + 9952 (clear-stream _test-output-stream) + 9953 (clear-stream $_test-output-buffered-file->buffer) + 9954 (clear-stream _test-error-stream) + 9955 (clear-stream $_test-error-buffered-file->buffer) + 9956 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 9957 68/push 0/imm32 + 9958 68/push 0/imm32 + 9959 89/<- %edx 4/r32/esp + 9960 (tailor-exit-descriptor %edx 0x10) + 9961 # + 9962 (write _test-input-stream "fn foo {\n") + 9963 (write _test-input-stream " var a: array\n") + 9964 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") + 9965 (write _test-input-stream "}\n") + 9966 # convert + 9967 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + 9968 # registers except esp clobbered at this point + 9969 # restore ed + 9970 89/<- %edx 4/r32/esp + 9971 (flush _test-output-buffered-file) + 9972 (flush _test-error-buffered-file) + 9973 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 9979 # check output + 9980 (check-stream-equal _test-output-stream "" "F - test-index-with-array-atom-base-type: output should be empty") + 9981 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: array 'a' must specify the type of its elements" "F - test-index-with-array-atom-base-type: error message") + 9982 # check that stop(1) was called + 9983 (check-ints-equal *(edx+4) 2 "F - test-index-with-array-atom-base-type: exit status") + 9984 # don't restore from ebp + 9985 81 0/subop/add %esp 8/imm32 + 9986 # . epilogue + 9987 5d/pop-to-ebp + 9988 c3/return + 9989 + 9990 test-index-with-addr-base-on-stack: + 9991 # . prologue + 9992 55/push-ebp + 9993 89/<- %ebp 4/r32/esp + 9994 # setup + 9995 (clear-stream _test-input-stream) + 9996 (clear-stream $_test-input-buffered-file->buffer) + 9997 (clear-stream _test-output-stream) + 9998 (clear-stream $_test-output-buffered-file->buffer) + 9999 (clear-stream _test-error-stream) +10000 (clear-stream $_test-error-buffered-file->buffer) +10001 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10002 68/push 0/imm32 +10003 68/push 0/imm32 +10004 89/<- %edx 4/r32/esp +10005 (tailor-exit-descriptor %edx 0x10) +10006 # +10007 (write _test-input-stream "fn foo {\n") +10008 (write _test-input-stream " var a: (addr array int)\n") +10009 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0\n") +10010 (write _test-input-stream "}\n") +10011 # convert +10012 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10013 # registers except esp clobbered at this point +10014 # restore ed +10015 89/<- %edx 4/r32/esp +10016 (flush _test-output-buffered-file) +10017 (flush _test-error-buffered-file) +10018 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10024 # check output +10025 (check-stream-equal _test-output-stream "" "F - test-index-with-addr-base-on-stack: output should be empty") +10026 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: var 'a' is an addr to an array, and so must live in a register" "F - test-index-with-addr-base-on-stack: error message") +10027 # check that stop(1) was called +10028 (check-ints-equal *(edx+4) 2 "F - test-index-with-addr-base-on-stack: exit status") +10029 # don't restore from ebp +10030 81 0/subop/add %esp 8/imm32 +10031 # . epilogue +10032 5d/pop-to-ebp +10033 c3/return +10034 +10035 test-index-with-wrong-index-type: +10036 # . prologue +10037 55/push-ebp +10038 89/<- %ebp 4/r32/esp +10039 # setup +10040 (clear-stream _test-input-stream) +10041 (clear-stream $_test-input-buffered-file->buffer) +10042 (clear-stream _test-output-stream) +10043 (clear-stream $_test-output-buffered-file->buffer) +10044 (clear-stream _test-error-stream) +10045 (clear-stream $_test-error-buffered-file->buffer) +10046 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10047 68/push 0/imm32 +10048 68/push 0/imm32 +10049 89/<- %edx 4/r32/esp +10050 (tailor-exit-descriptor %edx 0x10) +10051 # +10052 (write _test-input-stream "fn foo {\n") +10053 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n") +10054 (write _test-input-stream " var b: boolean\n") +10055 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n") +10056 (write _test-input-stream "}\n") +10057 # convert +10058 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10059 # registers except esp clobbered at this point +10060 # restore ed +10061 89/<- %edx 4/r32/esp +10062 (flush _test-output-buffered-file) +10063 (flush _test-error-buffered-file) +10064 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10070 # check output +10071 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-index-type: output should be empty") +10072 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: second argument 'b' must be an int or offset" "F - test-index-with-wrong-index-type: error message") +10073 # check that stop(1) was called +10074 (check-ints-equal *(edx+4) 2 "F - test-index-with-wrong-index-type: exit status") +10075 # don't restore from ebp +10076 81 0/subop/add %esp 8/imm32 +10077 # . epilogue +10078 5d/pop-to-ebp +10079 c3/return +10080 +10081 test-index-with-offset-atom-index-type: +10082 # . prologue +10083 55/push-ebp +10084 89/<- %ebp 4/r32/esp +10085 # setup +10086 (clear-stream _test-input-stream) +10087 (clear-stream $_test-input-buffered-file->buffer) +10088 (clear-stream _test-output-stream) +10089 (clear-stream $_test-output-buffered-file->buffer) +10090 (clear-stream _test-error-stream) +10091 (clear-stream $_test-error-buffered-file->buffer) +10092 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10093 68/push 0/imm32 +10094 68/push 0/imm32 +10095 89/<- %edx 4/r32/esp +10096 (tailor-exit-descriptor %edx 0x10) +10097 # +10098 (write _test-input-stream "fn foo {\n") +10099 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n") +10100 (write _test-input-stream " var b: offset\n") +10101 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n") +10102 (write _test-input-stream "}\n") +10103 # convert +10104 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10105 # registers except esp clobbered at this point +10106 # restore ed +10107 89/<- %edx 4/r32/esp +10108 (flush _test-output-buffered-file) +10109 (flush _test-error-buffered-file) +10110 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10116 # check output +10117 (check-stream-equal _test-output-stream "" "F - test-index-with-offset-atom-index-type: output should be empty") +10118 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: offset 'b' must specify the type of array elements" "F - test-index-with-offset-atom-index-type: error message") +10119 # check that stop(1) was called +10120 (check-ints-equal *(edx+4) 2 "F - test-index-with-offset-atom-index-type: exit status") +10121 # don't restore from ebp +10122 81 0/subop/add %esp 8/imm32 +10123 # . epilogue +10124 5d/pop-to-ebp +10125 c3/return +10126 +10127 test-index-with-offset-on-stack: +10128 # . prologue +10129 55/push-ebp +10130 89/<- %ebp 4/r32/esp +10131 # setup +10132 (clear-stream _test-input-stream) +10133 (clear-stream $_test-input-buffered-file->buffer) +10134 (clear-stream _test-output-stream) +10135 (clear-stream $_test-output-buffered-file->buffer) +10136 (clear-stream _test-error-stream) +10137 (clear-stream $_test-error-buffered-file->buffer) +10138 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10139 68/push 0/imm32 +10140 68/push 0/imm32 +10141 89/<- %edx 4/r32/esp +10142 (tailor-exit-descriptor %edx 0x10) +10143 # +10144 (write _test-input-stream "fn foo {\n") +10145 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n") +10146 (write _test-input-stream " var b: int\n") +10147 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n") +10148 (write _test-input-stream "}\n") +10149 # convert +10150 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10151 # registers except esp clobbered at this point +10152 # restore ed +10153 89/<- %edx 4/r32/esp +10154 (flush _test-output-buffered-file) +10155 (flush _test-error-buffered-file) +10156 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10162 # check output +10163 (check-stream-equal _test-output-stream "" "F - test-index-with-offset-on-stack: output should be empty") +10164 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: second argument 'b' must be in a register" "F - test-index-with-offset-on-stack: error message") +10165 # check that stop(1) was called +10166 (check-ints-equal *(edx+4) 2 "F - test-index-with-offset-on-stack: exit status") +10167 # don't restore from ebp +10168 81 0/subop/add %esp 8/imm32 +10169 # . epilogue +10170 5d/pop-to-ebp +10171 c3/return +10172 +10173 test-index-needs-offset-type: +10174 # . prologue +10175 55/push-ebp +10176 89/<- %ebp 4/r32/esp +10177 # setup +10178 (clear-stream _test-input-stream) +10179 (clear-stream $_test-input-buffered-file->buffer) +10180 (clear-stream _test-output-stream) +10181 (clear-stream $_test-output-buffered-file->buffer) +10182 (clear-stream _test-error-stream) +10183 (clear-stream $_test-error-buffered-file->buffer) +10184 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10185 68/push 0/imm32 +10186 68/push 0/imm32 +10187 89/<- %edx 4/r32/esp +10188 (tailor-exit-descriptor %edx 0x10) +10189 # +10190 (write _test-input-stream "fn foo {\n") +10191 (write _test-input-stream " var a/eax: (addr array t) <- copy 0\n") +10192 (write _test-input-stream " var b/ebx: int <- copy 0\n") +10193 (write _test-input-stream " var c/ecx: (addr int) <- index a, b\n") +10194 (write _test-input-stream "}\n") +10195 (write _test-input-stream "type t {\n") # size 12 is not a power of two +10196 (write _test-input-stream " x: int\n") +10197 (write _test-input-stream " y: int\n") +10198 (write _test-input-stream " z: int\n") +10199 (write _test-input-stream "}\n") +10200 # convert +10201 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10202 # registers except esp clobbered at this point +10203 # restore ed +10204 89/<- %edx 4/r32/esp +10205 (flush _test-output-buffered-file) +10206 (flush _test-error-buffered-file) +10207 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10213 # check output +10214 (check-stream-equal _test-output-stream "" "F - test-index-needs-offset-type: output should be empty") +10215 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: cannot take an int for array 'a'; create an offset instead. See mu.md for details." "F - test-index-needs-offset-type: error message") +10216 # check that stop(1) was called +10217 (check-ints-equal *(edx+4) 2 "F - test-index-needs-offset-type: exit status") +10218 # don't restore from ebp +10219 81 0/subop/add %esp 8/imm32 +10220 # . epilogue +10221 5d/pop-to-ebp +10222 c3/return +10223 +10224 test-index-with-output-not-address: +10225 # . prologue +10226 55/push-ebp +10227 89/<- %ebp 4/r32/esp +10228 # setup +10229 (clear-stream _test-input-stream) +10230 (clear-stream $_test-input-buffered-file->buffer) +10231 (clear-stream _test-output-stream) +10232 (clear-stream $_test-output-buffered-file->buffer) +10233 (clear-stream _test-error-stream) +10234 (clear-stream $_test-error-buffered-file->buffer) +10235 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10236 68/push 0/imm32 +10237 68/push 0/imm32 +10238 89/<- %edx 4/r32/esp +10239 (tailor-exit-descriptor %edx 0x10) +10240 # +10241 (write _test-input-stream "fn foo {\n") +10242 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") +10243 (write _test-input-stream " var o/edi: int <- index a, 0\n") +10244 (write _test-input-stream "}\n") +10245 # convert +10246 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10247 # registers except esp clobbered at this point +10248 # restore ed +10249 89/<- %edx 4/r32/esp +10250 (flush _test-output-buffered-file) +10251 (flush _test-error-buffered-file) +10252 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10258 # check output +10259 (check-stream-equal _test-output-stream "" "F - test-index-with-output-not-address: output should be empty") +10260 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' must be an addr" "F - test-index-with-output-not-address: error message") +10261 # check that stop(1) was called +10262 (check-ints-equal *(edx+4) 2 "F - test-index-with-output-not-address: exit status") +10263 # don't restore from ebp +10264 81 0/subop/add %esp 8/imm32 +10265 # . epilogue +10266 5d/pop-to-ebp +10267 c3/return +10268 +10269 test-index-with-output-not-address-2: +10270 # . prologue +10271 55/push-ebp +10272 89/<- %ebp 4/r32/esp +10273 # setup +10274 (clear-stream _test-input-stream) +10275 (clear-stream $_test-input-buffered-file->buffer) +10276 (clear-stream _test-output-stream) +10277 (clear-stream $_test-output-buffered-file->buffer) +10278 (clear-stream _test-error-stream) +10279 (clear-stream $_test-error-buffered-file->buffer) +10280 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10281 68/push 0/imm32 +10282 68/push 0/imm32 +10283 89/<- %edx 4/r32/esp +10284 (tailor-exit-descriptor %edx 0x10) +10285 # +10286 (write _test-input-stream "fn foo {\n") +10287 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") +10288 (write _test-input-stream " var o/edi: (int) <- index a, 0\n") +10289 (write _test-input-stream "}\n") +10290 # convert +10291 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10292 # registers except esp clobbered at this point +10293 # restore ed +10294 89/<- %edx 4/r32/esp +10295 (flush _test-output-buffered-file) +10296 (flush _test-error-buffered-file) +10297 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10303 # check output +10304 (check-stream-equal _test-output-stream "" "F - test-index-with-output-not-address-2: output should be empty") +10305 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' must be an addr" "F - test-index-with-output-not-address-2: error message") +10306 # check that stop(1) was called +10307 (check-ints-equal *(edx+4) 2 "F - test-index-with-output-not-address-2: exit status") +10308 # don't restore from ebp +10309 81 0/subop/add %esp 8/imm32 +10310 # . epilogue +10311 5d/pop-to-ebp +10312 c3/return +10313 +10314 test-index-with-wrong-output-type: +10315 # . prologue +10316 55/push-ebp +10317 89/<- %ebp 4/r32/esp +10318 # setup +10319 (clear-stream _test-input-stream) +10320 (clear-stream $_test-input-buffered-file->buffer) +10321 (clear-stream _test-output-stream) +10322 (clear-stream $_test-output-buffered-file->buffer) +10323 (clear-stream _test-error-stream) +10324 (clear-stream $_test-error-buffered-file->buffer) +10325 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10326 68/push 0/imm32 +10327 68/push 0/imm32 +10328 89/<- %edx 4/r32/esp +10329 (tailor-exit-descriptor %edx 0x10) +10330 # +10331 (write _test-input-stream "fn foo {\n") +10332 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") +10333 (write _test-input-stream " var o/edi: (addr int) <- index a, 0\n") +10334 (write _test-input-stream "}\n") +10335 # convert +10336 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10337 # registers except esp clobbered at this point +10338 # restore ed +10339 89/<- %edx 4/r32/esp +10340 (flush _test-output-buffered-file) +10341 (flush _test-error-buffered-file) +10342 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10348 # check output +10349 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-output-type: output should be empty") +10350 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' does not have the right type" "F - test-index-with-wrong-output-type: error message") +10351 # check that stop(1) was called +10352 (check-ints-equal *(edx+4) 2 "F - test-index-with-wrong-output-type: exit status") +10353 # don't restore from ebp +10354 81 0/subop/add %esp 8/imm32 +10355 # . epilogue +10356 5d/pop-to-ebp +10357 c3/return +10358 +10359 test-index-with-wrong-output-compound-type: +10360 # . prologue +10361 55/push-ebp +10362 89/<- %ebp 4/r32/esp +10363 # setup +10364 (clear-stream _test-input-stream) +10365 (clear-stream $_test-input-buffered-file->buffer) +10366 (clear-stream _test-output-stream) +10367 (clear-stream $_test-output-buffered-file->buffer) +10368 (clear-stream _test-error-stream) +10369 (clear-stream $_test-error-buffered-file->buffer) +10370 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10371 68/push 0/imm32 +10372 68/push 0/imm32 +10373 89/<- %edx 4/r32/esp +10374 (tailor-exit-descriptor %edx 0x10) +10375 # +10376 (write _test-input-stream "fn foo {\n") +10377 (write _test-input-stream " var a/ebx: (addr array handle boolean) <- copy 0\n") +10378 (write _test-input-stream " var o/edi: (addr handle int) <- index a, 0\n") +10379 (write _test-input-stream "}\n") +10380 # convert +10381 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10382 # registers except esp clobbered at this point +10383 # restore ed +10384 89/<- %edx 4/r32/esp +10385 (flush _test-output-buffered-file) +10386 (flush _test-error-buffered-file) +10387 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10393 # check output +10394 (check-stream-equal _test-output-stream "" "F - test-index-with-wrong-output-compound-type: output should be empty") +10395 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: output 'o' does not have the right type" "F - test-index-with-wrong-output-compound-type: error message") +10396 # check that stop(1) was called +10397 (check-ints-equal *(edx+4) 2 "F - test-index-with-wrong-output-compound-type: exit status") +10398 # don't restore from ebp +10399 81 0/subop/add %esp 8/imm32 +10400 # . epilogue +10401 5d/pop-to-ebp +10402 c3/return +10403 +10404 test-index-with-no-inouts: +10405 # . prologue +10406 55/push-ebp +10407 89/<- %ebp 4/r32/esp +10408 # setup +10409 (clear-stream _test-input-stream) +10410 (clear-stream $_test-input-buffered-file->buffer) +10411 (clear-stream _test-output-stream) +10412 (clear-stream $_test-output-buffered-file->buffer) +10413 (clear-stream _test-error-stream) +10414 (clear-stream $_test-error-buffered-file->buffer) +10415 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10416 68/push 0/imm32 +10417 68/push 0/imm32 +10418 89/<- %edx 4/r32/esp +10419 (tailor-exit-descriptor %edx 0x10) +10420 # +10421 (write _test-input-stream "fn foo {\n") +10422 (write _test-input-stream " var c/ecx: (addr int) <- index\n") +10423 (write _test-input-stream "}\n") +10424 # convert +10425 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10426 # registers except esp clobbered at this point +10427 # restore ed +10428 89/<- %edx 4/r32/esp +10429 (flush _test-output-buffered-file) +10430 (flush _test-error-buffered-file) +10431 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10437 # check output +10438 (check-stream-equal _test-output-stream "" "F - test-index-with-no-inouts: output should be empty") +10439 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too few inouts (2 required)" "F - test-index-with-no-inouts: error message") +10440 # check that stop(1) was called +10441 (check-ints-equal *(edx+4) 2 "F - test-index-with-no-inouts: exit status") +10442 # don't restore from ebp +10443 81 0/subop/add %esp 8/imm32 +10444 # . epilogue +10445 5d/pop-to-ebp +10446 c3/return +10447 +10448 test-index-with-too-few-inouts: +10449 # . prologue +10450 55/push-ebp +10451 89/<- %ebp 4/r32/esp +10452 # setup +10453 (clear-stream _test-input-stream) +10454 (clear-stream $_test-input-buffered-file->buffer) +10455 (clear-stream _test-output-stream) +10456 (clear-stream $_test-output-buffered-file->buffer) +10457 (clear-stream _test-error-stream) +10458 (clear-stream $_test-error-buffered-file->buffer) +10459 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10460 68/push 0/imm32 +10461 68/push 0/imm32 +10462 89/<- %edx 4/r32/esp +10463 (tailor-exit-descriptor %edx 0x10) +10464 # +10465 (write _test-input-stream "fn foo {\n") +10466 (write _test-input-stream " var a: (array int 3)\n") +10467 (write _test-input-stream " var c/ecx: (addr int) <- index a\n") +10468 (write _test-input-stream "}\n") +10469 # convert +10470 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10471 # registers except esp clobbered at this point +10472 # restore ed +10473 89/<- %edx 4/r32/esp +10474 (flush _test-output-buffered-file) +10475 (flush _test-error-buffered-file) +10476 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10482 # check output +10483 (check-stream-equal _test-output-stream "" "F - test-index-with-too-few-inouts: output should be empty") +10484 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too few inouts (2 required)" "F - test-index-with-too-few-inouts: error message") +10485 # check that stop(1) was called +10486 (check-ints-equal *(edx+4) 2 "F - test-index-with-too-few-inouts: exit status") +10487 # don't restore from ebp +10488 81 0/subop/add %esp 8/imm32 +10489 # . epilogue +10490 5d/pop-to-ebp +10491 c3/return +10492 +10493 test-index-with-too-many-inouts: +10494 # . prologue +10495 55/push-ebp +10496 89/<- %ebp 4/r32/esp +10497 # setup +10498 (clear-stream _test-input-stream) +10499 (clear-stream $_test-input-buffered-file->buffer) +10500 (clear-stream _test-output-stream) +10501 (clear-stream $_test-output-buffered-file->buffer) +10502 (clear-stream _test-error-stream) +10503 (clear-stream $_test-error-buffered-file->buffer) +10504 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10505 68/push 0/imm32 +10506 68/push 0/imm32 +10507 89/<- %edx 4/r32/esp +10508 (tailor-exit-descriptor %edx 0x10) +10509 # +10510 (write _test-input-stream "fn foo {\n") +10511 (write _test-input-stream " var a: (array int 3)\n") +10512 (write _test-input-stream " var c/ecx: (addr int) <- index a, 0, 0\n") +10513 (write _test-input-stream "}\n") +10514 # convert +10515 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10516 # registers except esp clobbered at this point +10517 # restore ed +10518 89/<- %edx 4/r32/esp +10519 (flush _test-output-buffered-file) +10520 (flush _test-error-buffered-file) +10521 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10527 # check output +10528 (check-stream-equal _test-output-stream "" "F - test-index-with-too-many-inouts: output should be empty") +10529 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too many inouts (2 required)" "F - test-index-with-too-many-inouts: error message") +10530 # check that stop(1) was called +10531 (check-ints-equal *(edx+4) 2 "F - test-index-with-too-many-inouts: exit status") +10532 # don't restore from ebp +10533 81 0/subop/add %esp 8/imm32 +10534 # . epilogue +10535 5d/pop-to-ebp +10536 c3/return +10537 +10538 test-index-with-no-output: +10539 # . prologue +10540 55/push-ebp +10541 89/<- %ebp 4/r32/esp +10542 # setup +10543 (clear-stream _test-input-stream) +10544 (clear-stream $_test-input-buffered-file->buffer) +10545 (clear-stream _test-output-stream) +10546 (clear-stream $_test-output-buffered-file->buffer) +10547 (clear-stream _test-error-stream) +10548 (clear-stream $_test-error-buffered-file->buffer) +10549 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10550 68/push 0/imm32 +10551 68/push 0/imm32 +10552 89/<- %edx 4/r32/esp +10553 (tailor-exit-descriptor %edx 0x10) +10554 # +10555 (write _test-input-stream "fn foo {\n") +10556 (write _test-input-stream " var a: (array int 3)\n") +10557 (write _test-input-stream " index a, 0\n") +10558 (write _test-input-stream "}\n") +10559 # convert +10560 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10561 # registers except esp clobbered at this point +10562 # restore ed +10563 89/<- %edx 4/r32/esp +10564 (flush _test-output-buffered-file) +10565 (flush _test-error-buffered-file) +10566 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10572 # check output +10573 (check-stream-equal _test-output-stream "" "F - test-index-with-no-output: output should be empty") +10574 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: must have an output" "F - test-index-with-no-output: error message") +10575 # check that stop(1) was called +10576 (check-ints-equal *(edx+4) 2 "F - test-index-with-no-output: exit status") +10577 # don't restore from ebp +10578 81 0/subop/add %esp 8/imm32 +10579 # . epilogue +10580 5d/pop-to-ebp +10581 c3/return +10582 +10583 test-index-with-too-many-outputs: +10584 # . prologue +10585 55/push-ebp +10586 89/<- %ebp 4/r32/esp +10587 # setup +10588 (clear-stream _test-input-stream) +10589 (clear-stream $_test-input-buffered-file->buffer) +10590 (clear-stream _test-output-stream) +10591 (clear-stream $_test-output-buffered-file->buffer) +10592 (clear-stream _test-error-stream) +10593 (clear-stream $_test-error-buffered-file->buffer) +10594 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10595 68/push 0/imm32 +10596 68/push 0/imm32 +10597 89/<- %edx 4/r32/esp +10598 (tailor-exit-descriptor %edx 0x10) +10599 # +10600 (write _test-input-stream "fn foo {\n") +10601 (write _test-input-stream " var a: (array int 3)\n") +10602 (write _test-input-stream " var b/eax: (addr int) <- copy 0\n") +10603 (write _test-input-stream " var c/ecx: (addr int) <- copy 0\n") +10604 (write _test-input-stream " b, c <- index a, 0\n") +10605 (write _test-input-stream "}\n") +10606 # convert +10607 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10608 # registers except esp clobbered at this point +10609 # restore ed +10610 89/<- %edx 4/r32/esp +10611 (flush _test-output-buffered-file) +10612 (flush _test-error-buffered-file) +10613 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10619 # check output +10620 (check-stream-equal _test-output-stream "" "F - test-index-with-too-many-outputs: output should be empty") +10621 (check-next-stream-line-equal _test-error-stream "fn foo: stmt index: too many outputs (1 required)" "F - test-index-with-too-many-outputs: error message") +10622 # check that stop(1) was called +10623 (check-ints-equal *(edx+4) 2 "F - test-index-with-too-many-outputs: exit status") +10624 # don't restore from ebp +10625 81 0/subop/add %esp 8/imm32 +10626 # . epilogue +10627 5d/pop-to-ebp +10628 c3/return +10629 +10630 test-compute-offset-with-non-array-atom-base-type: +10631 # . prologue +10632 55/push-ebp +10633 89/<- %ebp 4/r32/esp +10634 # setup +10635 (clear-stream _test-input-stream) +10636 (clear-stream $_test-input-buffered-file->buffer) +10637 (clear-stream _test-output-stream) +10638 (clear-stream $_test-output-buffered-file->buffer) +10639 (clear-stream _test-error-stream) +10640 (clear-stream $_test-error-buffered-file->buffer) +10641 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10642 68/push 0/imm32 +10643 68/push 0/imm32 +10644 89/<- %edx 4/r32/esp +10645 (tailor-exit-descriptor %edx 0x10) +10646 # +10647 (write _test-input-stream "fn foo {\n") +10648 (write _test-input-stream " var a: int\n") +10649 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n") +10650 (write _test-input-stream "}\n") +10651 # convert +10652 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10653 # registers except esp clobbered at this point +10654 # restore ed +10655 89/<- %edx 4/r32/esp +10656 (flush _test-output-buffered-file) +10657 (flush _test-error-buffered-file) +10658 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10664 # check output +10665 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-non-array-atom-base-type: output should be empty") +10666 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: var 'a' is not an array" "F - test-compute-offset-with-non-array-atom-base-type: error message") +10667 # check that stop(1) was called +10668 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-non-array-atom-base-type: exit status") +10669 # don't restore from ebp +10670 81 0/subop/add %esp 8/imm32 +10671 # . epilogue +10672 5d/pop-to-ebp +10673 c3/return +10674 +10675 test-compute-offset-with-non-array-compound-base-type: +10676 # . prologue +10677 55/push-ebp +10678 89/<- %ebp 4/r32/esp +10679 # setup +10680 (clear-stream _test-input-stream) +10681 (clear-stream $_test-input-buffered-file->buffer) +10682 (clear-stream _test-output-stream) +10683 (clear-stream $_test-output-buffered-file->buffer) +10684 (clear-stream _test-error-stream) +10685 (clear-stream $_test-error-buffered-file->buffer) +10686 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10687 68/push 0/imm32 +10688 68/push 0/imm32 +10689 89/<- %edx 4/r32/esp +10690 (tailor-exit-descriptor %edx 0x10) +10691 # +10692 (write _test-input-stream "fn foo {\n") +10693 (write _test-input-stream " var a: (handle int)\n") +10694 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n") +10695 (write _test-input-stream "}\n") +10696 # convert +10697 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10698 # registers except esp clobbered at this point +10699 # restore ed +10700 89/<- %edx 4/r32/esp +10701 (flush _test-output-buffered-file) +10702 (flush _test-error-buffered-file) +10703 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10709 # check output +10710 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-non-array-compound-base-type: output should be empty") +10711 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: var 'a' is not an array" "F - test-compute-offset-with-non-array-compound-base-type: error message") +10712 # check that stop(1) was called +10713 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-non-array-compound-base-type: exit status") +10714 # don't restore from ebp +10715 81 0/subop/add %esp 8/imm32 +10716 # . epilogue +10717 5d/pop-to-ebp +10718 c3/return +10719 +10720 test-compute-offset-with-non-array-compound-base-type-2: +10721 # . prologue +10722 55/push-ebp +10723 89/<- %ebp 4/r32/esp +10724 # setup +10725 (clear-stream _test-input-stream) +10726 (clear-stream $_test-input-buffered-file->buffer) +10727 (clear-stream _test-output-stream) +10728 (clear-stream $_test-output-buffered-file->buffer) +10729 (clear-stream _test-error-stream) +10730 (clear-stream $_test-error-buffered-file->buffer) +10731 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10732 68/push 0/imm32 +10733 68/push 0/imm32 +10734 89/<- %edx 4/r32/esp +10735 (tailor-exit-descriptor %edx 0x10) +10736 # +10737 (write _test-input-stream "fn foo {\n") +10738 (write _test-input-stream " var a: (addr int)\n") +10739 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n") +10740 (write _test-input-stream "}\n") +10741 # convert +10742 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10743 # registers except esp clobbered at this point +10744 # restore ed +10745 89/<- %edx 4/r32/esp +10746 (flush _test-output-buffered-file) +10747 (flush _test-error-buffered-file) +10748 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10754 # check output +10755 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-non-array-compound-base-type-2: output should be empty") +10756 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: var 'a' is not an array" "F - test-compute-offset-with-non-array-compound-base-type-2: error message") +10757 # check that stop(1) was called +10758 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-non-array-compound-base-type-2: exit status") +10759 # don't restore from ebp +10760 81 0/subop/add %esp 8/imm32 +10761 # . epilogue +10762 5d/pop-to-ebp +10763 c3/return +10764 +10765 test-compute-offset-with-array-atom-base-type: +10766 # . prologue +10767 55/push-ebp +10768 89/<- %ebp 4/r32/esp +10769 # setup +10770 (clear-stream _test-input-stream) +10771 (clear-stream $_test-input-buffered-file->buffer) +10772 (clear-stream _test-output-stream) +10773 (clear-stream $_test-output-buffered-file->buffer) +10774 (clear-stream _test-error-stream) +10775 (clear-stream $_test-error-buffered-file->buffer) +10776 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10777 68/push 0/imm32 +10778 68/push 0/imm32 +10779 89/<- %edx 4/r32/esp +10780 (tailor-exit-descriptor %edx 0x10) +10781 # +10782 (write _test-input-stream "fn foo {\n") +10783 (write _test-input-stream " var a: array\n") +10784 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0\n") +10785 (write _test-input-stream "}\n") +10786 # convert +10787 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10788 # registers except esp clobbered at this point +10789 # restore ed +10790 89/<- %edx 4/r32/esp +10791 (flush _test-output-buffered-file) +10792 (flush _test-error-buffered-file) +10793 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10799 # check output +10800 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-array-atom-base-type: output should be empty") +10801 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: array 'a' must specify the type of its elements" "F - test-compute-offset-with-array-atom-base-type: error message") +10802 # check that stop(1) was called +10803 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-array-atom-base-type: exit status") +10804 # don't restore from ebp +10805 81 0/subop/add %esp 8/imm32 +10806 # . epilogue +10807 5d/pop-to-ebp +10808 c3/return +10809 +10810 test-compute-offset-with-wrong-index-type: +10811 # . prologue +10812 55/push-ebp +10813 89/<- %ebp 4/r32/esp +10814 # setup +10815 (clear-stream _test-input-stream) +10816 (clear-stream $_test-input-buffered-file->buffer) +10817 (clear-stream _test-output-stream) +10818 (clear-stream $_test-output-buffered-file->buffer) +10819 (clear-stream _test-error-stream) +10820 (clear-stream $_test-error-buffered-file->buffer) +10821 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10822 68/push 0/imm32 +10823 68/push 0/imm32 +10824 89/<- %edx 4/r32/esp +10825 (tailor-exit-descriptor %edx 0x10) +10826 # +10827 (write _test-input-stream "fn foo {\n") +10828 (write _test-input-stream " var a/eax: (addr array int) <- copy 0\n") +10829 (write _test-input-stream " var b: boolean\n") +10830 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, b\n") +10831 (write _test-input-stream "}\n") +10832 # convert +10833 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10834 # registers except esp clobbered at this point +10835 # restore ed +10836 89/<- %edx 4/r32/esp +10837 (flush _test-output-buffered-file) +10838 (flush _test-error-buffered-file) +10839 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10845 # check output +10846 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-wrong-index-type: output should be empty") +10847 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: second argument 'b' must be an int" "F - test-compute-offset-with-wrong-index-type: error message") +10848 # check that stop(1) was called +10849 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-wrong-index-type: exit status") +10850 # don't restore from ebp +10851 81 0/subop/add %esp 8/imm32 +10852 # . epilogue +10853 5d/pop-to-ebp +10854 c3/return +10855 +10856 test-compute-offset-with-output-not-offset: +10857 # . prologue +10858 55/push-ebp +10859 89/<- %ebp 4/r32/esp +10860 # setup +10861 (clear-stream _test-input-stream) +10862 (clear-stream $_test-input-buffered-file->buffer) +10863 (clear-stream _test-output-stream) +10864 (clear-stream $_test-output-buffered-file->buffer) +10865 (clear-stream _test-error-stream) +10866 (clear-stream $_test-error-buffered-file->buffer) +10867 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10868 68/push 0/imm32 +10869 68/push 0/imm32 10870 89/<- %edx 4/r32/esp -10871 (flush _test-output-buffered-file) -10872 (flush _test-error-buffered-file) -10873 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10879 # check output -10880 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-non-stream-compound-base-type: output should be empty") -10881 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-non-stream-compound-base-type: error message") -10882 # check that stop(1) was called -10883 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-non-stream-compound-base-type: exit status") -10884 # don't restore from ebp -10885 81 0/subop/add %esp 8/imm32 -10886 # . epilogue -10887 5d/pop-to-ebp -10888 c3/return -10889 -10890 test-read-from-stream-with-non-stream-compound-base-type-2: -10891 # . prologue -10892 55/push-ebp -10893 89/<- %ebp 4/r32/esp -10894 # setup -10895 (clear-stream _test-input-stream) -10896 (clear-stream $_test-input-buffered-file->buffer) -10897 (clear-stream _test-output-stream) -10898 (clear-stream $_test-output-buffered-file->buffer) -10899 (clear-stream _test-error-stream) -10900 (clear-stream $_test-error-buffered-file->buffer) -10901 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10902 68/push 0/imm32 -10903 68/push 0/imm32 -10904 89/<- %edx 4/r32/esp -10905 (tailor-exit-descriptor %edx 0x10) -10906 # -10907 (write _test-input-stream "fn foo {\n") -10908 (write _test-input-stream " var a: (addr int)\n") -10909 (write _test-input-stream " read-from-stream a, 0\n") -10910 (write _test-input-stream "}\n") -10911 # convert -10912 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10913 # registers except esp clobbered at this point -10914 # restore ed +10871 (tailor-exit-descriptor %edx 0x10) +10872 # +10873 (write _test-input-stream "fn foo {\n") +10874 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") +10875 (write _test-input-stream " var o/edi: int <- compute-offset a, 0\n") +10876 (write _test-input-stream "}\n") +10877 # convert +10878 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10879 # registers except esp clobbered at this point +10880 # restore ed +10881 89/<- %edx 4/r32/esp +10882 (flush _test-output-buffered-file) +10883 (flush _test-error-buffered-file) +10884 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10890 # check output +10891 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-output-not-offset: output should be empty") +10892 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' must be an offset" "F - test-compute-offset-with-output-not-offset: error message") +10893 # check that stop(1) was called +10894 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-output-not-offset: exit status") +10895 # don't restore from ebp +10896 81 0/subop/add %esp 8/imm32 +10897 # . epilogue +10898 5d/pop-to-ebp +10899 c3/return +10900 +10901 test-compute-offset-with-output-not-address-2: +10902 # . prologue +10903 55/push-ebp +10904 89/<- %ebp 4/r32/esp +10905 # setup +10906 (clear-stream _test-input-stream) +10907 (clear-stream $_test-input-buffered-file->buffer) +10908 (clear-stream _test-output-stream) +10909 (clear-stream $_test-output-buffered-file->buffer) +10910 (clear-stream _test-error-stream) +10911 (clear-stream $_test-error-buffered-file->buffer) +10912 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10913 68/push 0/imm32 +10914 68/push 0/imm32 10915 89/<- %edx 4/r32/esp -10916 (flush _test-output-buffered-file) -10917 (flush _test-error-buffered-file) -10918 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10924 # check output -10925 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-non-stream-compound-base-type-2: output should be empty") -10926 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-non-stream-compound-base-type-2: error message") -10927 # check that stop(1) was called -10928 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-non-stream-compound-base-type-2: exit status") -10929 # don't restore from ebp -10930 81 0/subop/add %esp 8/imm32 -10931 # . epilogue -10932 5d/pop-to-ebp -10933 c3/return -10934 -10935 test-read-from-stream-with-stream-atom-base-type: -10936 # . prologue -10937 55/push-ebp -10938 89/<- %ebp 4/r32/esp -10939 # setup -10940 (clear-stream _test-input-stream) -10941 (clear-stream $_test-input-buffered-file->buffer) -10942 (clear-stream _test-output-stream) -10943 (clear-stream $_test-output-buffered-file->buffer) -10944 (clear-stream _test-error-stream) -10945 (clear-stream $_test-error-buffered-file->buffer) -10946 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10947 68/push 0/imm32 -10948 68/push 0/imm32 -10949 89/<- %edx 4/r32/esp -10950 (tailor-exit-descriptor %edx 0x10) -10951 # -10952 (write _test-input-stream "fn foo {\n") -10953 (write _test-input-stream " var a: stream\n") -10954 (write _test-input-stream " read-from-stream a, 0\n") -10955 (write _test-input-stream "}\n") -10956 # convert -10957 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -10958 # registers except esp clobbered at this point -10959 # restore ed +10916 (tailor-exit-descriptor %edx 0x10) +10917 # +10918 (write _test-input-stream "fn foo {\n") +10919 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") +10920 (write _test-input-stream " var o/edi: (int) <- compute-offset a, 0\n") +10921 (write _test-input-stream "}\n") +10922 # convert +10923 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10924 # registers except esp clobbered at this point +10925 # restore ed +10926 89/<- %edx 4/r32/esp +10927 (flush _test-output-buffered-file) +10928 (flush _test-error-buffered-file) +10929 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10935 # check output +10936 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-output-not-address-2: output should be empty") +10937 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' must be an offset" "F - test-compute-offset-with-output-not-address-2: error message") +10938 # check that stop(1) was called +10939 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-output-not-address-2: exit status") +10940 # don't restore from ebp +10941 81 0/subop/add %esp 8/imm32 +10942 # . epilogue +10943 5d/pop-to-ebp +10944 c3/return +10945 +10946 test-compute-offset-with-wrong-output-type: +10947 # . prologue +10948 55/push-ebp +10949 89/<- %ebp 4/r32/esp +10950 # setup +10951 (clear-stream _test-input-stream) +10952 (clear-stream $_test-input-buffered-file->buffer) +10953 (clear-stream _test-output-stream) +10954 (clear-stream $_test-output-buffered-file->buffer) +10955 (clear-stream _test-error-stream) +10956 (clear-stream $_test-error-buffered-file->buffer) +10957 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +10958 68/push 0/imm32 +10959 68/push 0/imm32 10960 89/<- %edx 4/r32/esp -10961 (flush _test-output-buffered-file) -10962 (flush _test-error-buffered-file) -10963 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -10969 # check output -10970 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-stream-atom-base-type: output should be empty") -10971 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-stream-atom-base-type: error message") -10972 # check that stop(1) was called -10973 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-stream-atom-base-type: exit status") -10974 # don't restore from ebp -10975 81 0/subop/add %esp 8/imm32 -10976 # . epilogue -10977 5d/pop-to-ebp -10978 c3/return -10979 -10980 test-read-from-stream-with-wrong-index-type: -10981 # . prologue -10982 55/push-ebp -10983 89/<- %ebp 4/r32/esp -10984 # setup -10985 (clear-stream _test-input-stream) -10986 (clear-stream $_test-input-buffered-file->buffer) -10987 (clear-stream _test-output-stream) -10988 (clear-stream $_test-output-buffered-file->buffer) -10989 (clear-stream _test-error-stream) -10990 (clear-stream $_test-error-buffered-file->buffer) -10991 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -10992 68/push 0/imm32 -10993 68/push 0/imm32 -10994 89/<- %edx 4/r32/esp -10995 (tailor-exit-descriptor %edx 0x10) -10996 # -10997 (write _test-input-stream "fn foo {\n") -10998 (write _test-input-stream " var a/eax: (addr stream int) <- copy 0\n") -10999 (write _test-input-stream " var b: boolean\n") -11000 (write _test-input-stream " read-from-stream a, b\n") -11001 (write _test-input-stream "}\n") -11002 # convert -11003 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11004 # registers except esp clobbered at this point -11005 # restore ed -11006 89/<- %edx 4/r32/esp -11007 (flush _test-output-buffered-file) -11008 (flush _test-error-buffered-file) -11009 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11015 # check output -11016 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-wrong-index-type: output should be empty") -11017 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: target 'b' must be an addr" "F - test-read-from-stream-with-wrong-index-type: error message") -11018 # check that stop(1) was called -11019 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-wrong-index-type: exit status") -11020 # don't restore from ebp -11021 81 0/subop/add %esp 8/imm32 -11022 # . epilogue -11023 5d/pop-to-ebp -11024 c3/return -11025 -11026 test-read-from-stream-with-no-inouts: -11027 # . prologue -11028 55/push-ebp -11029 89/<- %ebp 4/r32/esp -11030 # setup -11031 (clear-stream _test-input-stream) -11032 (clear-stream $_test-input-buffered-file->buffer) -11033 (clear-stream _test-output-stream) -11034 (clear-stream $_test-output-buffered-file->buffer) -11035 (clear-stream _test-error-stream) -11036 (clear-stream $_test-error-buffered-file->buffer) -11037 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11038 68/push 0/imm32 -11039 68/push 0/imm32 -11040 89/<- %edx 4/r32/esp -11041 (tailor-exit-descriptor %edx 0x10) -11042 # -11043 (write _test-input-stream "fn foo {\n") -11044 (write _test-input-stream " read-from-stream\n") -11045 (write _test-input-stream "}\n") -11046 # convert -11047 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11048 # registers except esp clobbered at this point -11049 # restore ed +10961 (tailor-exit-descriptor %edx 0x10) +10962 # +10963 (write _test-input-stream "fn foo {\n") +10964 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") +10965 (write _test-input-stream " var o/edi: (offset int) <- compute-offset a, 0\n") +10966 (write _test-input-stream "}\n") +10967 # convert +10968 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +10969 # registers except esp clobbered at this point +10970 # restore ed +10971 89/<- %edx 4/r32/esp +10972 (flush _test-output-buffered-file) +10973 (flush _test-error-buffered-file) +10974 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +10980 # check output +10981 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-wrong-output-type: output should be empty") +10982 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' does not have the right type" "F - test-compute-offset-with-wrong-output-type: error message") +10983 # check that stop(1) was called +10984 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-wrong-output-type: exit status") +10985 # don't restore from ebp +10986 81 0/subop/add %esp 8/imm32 +10987 # . epilogue +10988 5d/pop-to-ebp +10989 c3/return +10990 +10991 test-compute-offset-with-wrong-output-compound-type: +10992 # . prologue +10993 55/push-ebp +10994 89/<- %ebp 4/r32/esp +10995 # setup +10996 (clear-stream _test-input-stream) +10997 (clear-stream $_test-input-buffered-file->buffer) +10998 (clear-stream _test-output-stream) +10999 (clear-stream $_test-output-buffered-file->buffer) +11000 (clear-stream _test-error-stream) +11001 (clear-stream $_test-error-buffered-file->buffer) +11002 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11003 68/push 0/imm32 +11004 68/push 0/imm32 +11005 89/<- %edx 4/r32/esp +11006 (tailor-exit-descriptor %edx 0x10) +11007 # +11008 (write _test-input-stream "fn foo {\n") +11009 (write _test-input-stream " var a/ebx: (addr array handle boolean) <- copy 0\n") +11010 (write _test-input-stream " var o/edi: (offset handle int) <- compute-offset a, 0\n") +11011 (write _test-input-stream "}\n") +11012 # convert +11013 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11014 # registers except esp clobbered at this point +11015 # restore ed +11016 89/<- %edx 4/r32/esp +11017 (flush _test-output-buffered-file) +11018 (flush _test-error-buffered-file) +11019 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11025 # check output +11026 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-wrong-output-compound-type: output should be empty") +11027 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: output 'o' does not have the right type" "F - test-compute-offset-with-wrong-output-compound-type: error message") +11028 # check that stop(1) was called +11029 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-wrong-output-compound-type: exit status") +11030 # don't restore from ebp +11031 81 0/subop/add %esp 8/imm32 +11032 # . epilogue +11033 5d/pop-to-ebp +11034 c3/return +11035 +11036 test-compute-offset-with-no-inouts: +11037 # . prologue +11038 55/push-ebp +11039 89/<- %ebp 4/r32/esp +11040 # setup +11041 (clear-stream _test-input-stream) +11042 (clear-stream $_test-input-buffered-file->buffer) +11043 (clear-stream _test-output-stream) +11044 (clear-stream $_test-output-buffered-file->buffer) +11045 (clear-stream _test-error-stream) +11046 (clear-stream $_test-error-buffered-file->buffer) +11047 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11048 68/push 0/imm32 +11049 68/push 0/imm32 11050 89/<- %edx 4/r32/esp -11051 (flush _test-output-buffered-file) -11052 (flush _test-error-buffered-file) -11053 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11059 # check output -11060 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-no-inouts: output should be empty") -11061 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: too few inouts (2 required)" "F - test-read-from-stream-with-no-inouts: error message") -11062 # check that stop(1) was called -11063 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-no-inouts: exit status") -11064 # don't restore from ebp -11065 81 0/subop/add %esp 8/imm32 -11066 # . epilogue -11067 5d/pop-to-ebp -11068 c3/return -11069 -11070 test-read-from-stream-with-too-few-inouts: -11071 # . prologue -11072 55/push-ebp -11073 89/<- %ebp 4/r32/esp -11074 # setup -11075 (clear-stream _test-input-stream) -11076 (clear-stream $_test-input-buffered-file->buffer) -11077 (clear-stream _test-output-stream) -11078 (clear-stream $_test-output-buffered-file->buffer) -11079 (clear-stream _test-error-stream) -11080 (clear-stream $_test-error-buffered-file->buffer) -11081 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11082 68/push 0/imm32 -11083 68/push 0/imm32 -11084 89/<- %edx 4/r32/esp -11085 (tailor-exit-descriptor %edx 0x10) -11086 # -11087 (write _test-input-stream "fn foo {\n") -11088 (write _test-input-stream " var a: (addr stream int)\n") -11089 (write _test-input-stream " read-from-stream a\n") -11090 (write _test-input-stream "}\n") -11091 # convert -11092 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11093 # registers except esp clobbered at this point -11094 # restore ed -11095 89/<- %edx 4/r32/esp -11096 (flush _test-output-buffered-file) -11097 (flush _test-error-buffered-file) -11098 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11104 # check output -11105 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-too-few-inouts: output should be empty") -11106 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: too few inouts (2 required)" "F - test-read-from-stream-with-too-few-inouts: error message") -11107 # check that stop(1) was called -11108 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-too-few-inouts: exit status") -11109 # don't restore from ebp -11110 81 0/subop/add %esp 8/imm32 -11111 # . epilogue -11112 5d/pop-to-ebp -11113 c3/return -11114 -11115 test-read-from-stream-with-too-many-inouts: -11116 # . prologue -11117 55/push-ebp -11118 89/<- %ebp 4/r32/esp -11119 # setup -11120 (clear-stream _test-input-stream) -11121 (clear-stream $_test-input-buffered-file->buffer) -11122 (clear-stream _test-output-stream) -11123 (clear-stream $_test-output-buffered-file->buffer) -11124 (clear-stream _test-error-stream) -11125 (clear-stream $_test-error-buffered-file->buffer) -11126 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11127 68/push 0/imm32 -11128 68/push 0/imm32 -11129 89/<- %edx 4/r32/esp -11130 (tailor-exit-descriptor %edx 0x10) -11131 # -11132 (write _test-input-stream "fn foo {\n") -11133 (write _test-input-stream " var a: (addr stream int)\n") -11134 (write _test-input-stream " var b: (addr int)\n") -11135 (write _test-input-stream " read-from-stream a, b, 0\n") -11136 (write _test-input-stream "}\n") -11137 # convert -11138 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11139 # registers except esp clobbered at this point -11140 # restore ed -11141 89/<- %edx 4/r32/esp -11142 (flush _test-output-buffered-file) -11143 (flush _test-error-buffered-file) -11144 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11150 # check output -11151 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-too-many-inouts: output should be empty") -11152 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: too many inouts (2 required)" "F - test-read-from-stream-with-too-many-inouts: error message") -11153 # check that stop(1) was called -11154 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-too-many-inouts: exit status") -11155 # don't restore from ebp -11156 81 0/subop/add %esp 8/imm32 -11157 # . epilogue -11158 5d/pop-to-ebp -11159 c3/return -11160 -11161 test-read-from-stream-with-output: -11162 # . prologue -11163 55/push-ebp -11164 89/<- %ebp 4/r32/esp -11165 # setup -11166 (clear-stream _test-input-stream) -11167 (clear-stream $_test-input-buffered-file->buffer) -11168 (clear-stream _test-output-stream) -11169 (clear-stream $_test-output-buffered-file->buffer) -11170 (clear-stream _test-error-stream) -11171 (clear-stream $_test-error-buffered-file->buffer) -11172 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11173 68/push 0/imm32 -11174 68/push 0/imm32 -11175 89/<- %edx 4/r32/esp -11176 (tailor-exit-descriptor %edx 0x10) -11177 # -11178 (write _test-input-stream "fn foo {\n") -11179 (write _test-input-stream " var a: (addr stream int)\n") -11180 (write _test-input-stream " var b/eax: (addr int) <- copy 0\n") -11181 (write _test-input-stream " b <- read-from-stream a, b\n") -11182 (write _test-input-stream "}\n") -11183 # convert -11184 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11185 # registers except esp clobbered at this point -11186 # restore ed -11187 89/<- %edx 4/r32/esp -11188 (flush _test-output-buffered-file) -11189 (flush _test-error-buffered-file) -11190 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11196 # check output -11197 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-output: output should be empty") -11198 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: unexpected output" "F - test-read-from-stream-with-output: error message") -11199 # check that stop(1) was called -11200 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-output: exit status") -11201 # don't restore from ebp -11202 81 0/subop/add %esp 8/imm32 -11203 # . epilogue -11204 5d/pop-to-ebp -11205 c3/return -11206 -11207 test-convert-write-to-stream: -11208 # . prologue -11209 55/push-ebp -11210 89/<- %ebp 4/r32/esp -11211 # setup -11212 (clear-stream _test-input-stream) -11213 (clear-stream $_test-input-buffered-file->buffer) -11214 (clear-stream _test-output-stream) -11215 (clear-stream $_test-output-buffered-file->buffer) -11216 # -11217 (write _test-input-stream "fn foo {\n") -11218 (write _test-input-stream " var s/esi: (addr stream int) <- copy 0\n") -11219 (write _test-input-stream " var o/ecx: (addr int) <- copy 0\n") -11220 (write _test-input-stream " write-to-stream s, o\n") -11221 (write _test-input-stream "}\n") -11222 # convert -11223 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -11224 # registers except esp clobbered at this point -11225 # restore ed -11226 89/<- %edx 4/r32/esp -11227 (flush _test-output-buffered-file) -11228 (flush _test-error-buffered-file) -11229 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11235 # check output -11236 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-write-to-stream/0") -11237 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-write-to-stream/1") -11238 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-write-to-stream/2") -11239 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-write-to-stream/3") -11240 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-write-to-stream/4") -11241 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-write-to-stream/5") -11242 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-write-to-stream/6") -11243 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-write-to-stream/7") -11244 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-write-to-stream/8") -11245 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-write-to-stream/9") -11246 (check-next-stream-line-equal _test-output-stream " (write-to-stream %esi %ecx 0x00000004)" "F - test-convert-write-to-stream/10") -11247 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-write-to-stream/11") -11248 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-write-to-stream/12") -11249 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-write-to-stream/13") -11250 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-write-to-stream/14") -11251 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-write-to-stream/15") -11252 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-write-to-stream/16") -11253 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-write-to-stream/17") -11254 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-write-to-stream/18") -11255 # . epilogue -11256 89/<- %esp 5/r32/ebp -11257 5d/pop-to-ebp -11258 c3/return -11259 -11260 test-convert-write-to-stream-with-correct-payload-size: -11261 # . prologue -11262 55/push-ebp -11263 89/<- %ebp 4/r32/esp -11264 # setup -11265 (clear-stream _test-input-stream) -11266 (clear-stream $_test-input-buffered-file->buffer) -11267 (clear-stream _test-output-stream) -11268 (clear-stream $_test-output-buffered-file->buffer) -11269 # -11270 (write _test-input-stream "fn foo {\n") -11271 (write _test-input-stream " var s/esi: (addr stream handle int) <- copy 0\n") -11272 (write _test-input-stream " var o/ecx: (addr handle int) <- copy 0\n") -11273 (write _test-input-stream " write-to-stream s, o\n") -11274 (write _test-input-stream "}\n") -11275 # convert -11276 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -11277 # registers except esp clobbered at this point -11278 # restore ed -11279 89/<- %edx 4/r32/esp -11280 (flush _test-output-buffered-file) -11281 (flush _test-error-buffered-file) -11282 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11288 # check output -11289 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-write-to-stream-with-correct-payload-size/0") -11290 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-write-to-stream-with-correct-payload-size/1") -11291 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-write-to-stream-with-correct-payload-size/2") -11292 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-write-to-stream-with-correct-payload-size/3") -11293 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-write-to-stream-with-correct-payload-size/4") -11294 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-write-to-stream-with-correct-payload-size/5") -11295 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-write-to-stream-with-correct-payload-size/6") -11296 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-write-to-stream-with-correct-payload-size/7") -11297 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-write-to-stream-with-correct-payload-size/8") -11298 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-write-to-stream-with-correct-payload-size/9") -11299 (check-next-stream-line-equal _test-output-stream " (write-to-stream %esi %ecx 0x00000008)" "F - test-convert-write-to-stream-with-correct-payload-size/10") -11300 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-write-to-stream-with-correct-payload-size/11") -11301 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-write-to-stream-with-correct-payload-size/12") -11302 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-write-to-stream-with-correct-payload-size/13") -11303 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-write-to-stream-with-correct-payload-size/14") -11304 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-write-to-stream-with-correct-payload-size/15") -11305 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-write-to-stream-with-correct-payload-size/16") -11306 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-write-to-stream-with-correct-payload-size/17") -11307 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-write-to-stream-with-correct-payload-size/18") -11308 # . epilogue -11309 89/<- %esp 5/r32/ebp -11310 5d/pop-to-ebp -11311 c3/return -11312 -11313 test-write-to-stream-with-non-stream-atom-base-type: -11314 # . prologue -11315 55/push-ebp -11316 89/<- %ebp 4/r32/esp -11317 # setup -11318 (clear-stream _test-input-stream) -11319 (clear-stream $_test-input-buffered-file->buffer) -11320 (clear-stream _test-output-stream) -11321 (clear-stream $_test-output-buffered-file->buffer) -11322 (clear-stream _test-error-stream) -11323 (clear-stream $_test-error-buffered-file->buffer) -11324 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11325 68/push 0/imm32 -11326 68/push 0/imm32 -11327 89/<- %edx 4/r32/esp -11328 (tailor-exit-descriptor %edx 0x10) -11329 # -11330 (write _test-input-stream "fn foo {\n") -11331 (write _test-input-stream " var a: int\n") -11332 (write _test-input-stream " write-to-stream a, 0\n") -11333 (write _test-input-stream "}\n") -11334 # convert -11335 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11336 # registers except esp clobbered at this point -11337 # restore ed -11338 89/<- %edx 4/r32/esp -11339 (flush _test-output-buffered-file) -11340 (flush _test-error-buffered-file) -11341 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11347 # check output -11348 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-non-stream-atom-base-type: output should be empty") -11349 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-non-stream-atom-base-type: error message") -11350 # check that stop(1) was called -11351 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-non-stream-atom-base-type: exit status") -11352 # don't restore from ebp -11353 81 0/subop/add %esp 8/imm32 -11354 # . epilogue -11355 5d/pop-to-ebp -11356 c3/return -11357 -11358 test-write-to-stream-with-non-stream-compound-base-type: -11359 # . prologue -11360 55/push-ebp -11361 89/<- %ebp 4/r32/esp -11362 # setup -11363 (clear-stream _test-input-stream) -11364 (clear-stream $_test-input-buffered-file->buffer) -11365 (clear-stream _test-output-stream) -11366 (clear-stream $_test-output-buffered-file->buffer) -11367 (clear-stream _test-error-stream) -11368 (clear-stream $_test-error-buffered-file->buffer) -11369 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11370 68/push 0/imm32 -11371 68/push 0/imm32 -11372 89/<- %edx 4/r32/esp -11373 (tailor-exit-descriptor %edx 0x10) -11374 # -11375 (write _test-input-stream "fn foo {\n") -11376 (write _test-input-stream " var a: (handle int)\n") -11377 (write _test-input-stream " write-to-stream a, 0\n") -11378 (write _test-input-stream "}\n") -11379 # convert -11380 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11381 # registers except esp clobbered at this point -11382 # restore ed -11383 89/<- %edx 4/r32/esp -11384 (flush _test-output-buffered-file) -11385 (flush _test-error-buffered-file) -11386 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11392 # check output -11393 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-non-stream-compound-base-type: output should be empty") -11394 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-non-stream-compound-base-type: error message") -11395 # check that stop(1) was called -11396 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-non-stream-compound-base-type: exit status") -11397 # don't restore from ebp -11398 81 0/subop/add %esp 8/imm32 -11399 # . epilogue -11400 5d/pop-to-ebp -11401 c3/return -11402 -11403 test-write-to-stream-with-non-stream-compound-base-type-2: -11404 # . prologue -11405 55/push-ebp -11406 89/<- %ebp 4/r32/esp -11407 # setup -11408 (clear-stream _test-input-stream) -11409 (clear-stream $_test-input-buffered-file->buffer) -11410 (clear-stream _test-output-stream) -11411 (clear-stream $_test-output-buffered-file->buffer) -11412 (clear-stream _test-error-stream) -11413 (clear-stream $_test-error-buffered-file->buffer) -11414 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11415 68/push 0/imm32 -11416 68/push 0/imm32 -11417 89/<- %edx 4/r32/esp -11418 (tailor-exit-descriptor %edx 0x10) -11419 # -11420 (write _test-input-stream "fn foo {\n") -11421 (write _test-input-stream " var a: (addr int)\n") -11422 (write _test-input-stream " write-to-stream a, 0\n") -11423 (write _test-input-stream "}\n") -11424 # convert -11425 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11426 # registers except esp clobbered at this point -11427 # restore ed -11428 89/<- %edx 4/r32/esp -11429 (flush _test-output-buffered-file) -11430 (flush _test-error-buffered-file) -11431 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11437 # check output -11438 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-non-stream-compound-base-type-2: output should be empty") -11439 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-non-stream-compound-base-type-2: error message") -11440 # check that stop(1) was called -11441 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-non-stream-compound-base-type-2: exit status") -11442 # don't restore from ebp -11443 81 0/subop/add %esp 8/imm32 -11444 # . epilogue -11445 5d/pop-to-ebp -11446 c3/return -11447 -11448 test-write-to-stream-with-stream-atom-base-type: -11449 # . prologue -11450 55/push-ebp -11451 89/<- %ebp 4/r32/esp -11452 # setup -11453 (clear-stream _test-input-stream) -11454 (clear-stream $_test-input-buffered-file->buffer) -11455 (clear-stream _test-output-stream) -11456 (clear-stream $_test-output-buffered-file->buffer) -11457 (clear-stream _test-error-stream) -11458 (clear-stream $_test-error-buffered-file->buffer) -11459 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11460 68/push 0/imm32 -11461 68/push 0/imm32 -11462 89/<- %edx 4/r32/esp -11463 (tailor-exit-descriptor %edx 0x10) -11464 # -11465 (write _test-input-stream "fn foo {\n") -11466 (write _test-input-stream " var a: stream\n") -11467 (write _test-input-stream " write-to-stream a, 0\n") -11468 (write _test-input-stream "}\n") -11469 # convert -11470 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11471 # registers except esp clobbered at this point -11472 # restore ed -11473 89/<- %edx 4/r32/esp -11474 (flush _test-output-buffered-file) -11475 (flush _test-error-buffered-file) -11476 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11482 # check output -11483 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-stream-atom-base-type: output should be empty") -11484 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-stream-atom-base-type: error message") -11485 # check that stop(1) was called -11486 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-stream-atom-base-type: exit status") -11487 # don't restore from ebp -11488 81 0/subop/add %esp 8/imm32 -11489 # . epilogue -11490 5d/pop-to-ebp -11491 c3/return -11492 -11493 test-write-to-stream-with-wrong-index-type: -11494 # . prologue -11495 55/push-ebp -11496 89/<- %ebp 4/r32/esp -11497 # setup -11498 (clear-stream _test-input-stream) -11499 (clear-stream $_test-input-buffered-file->buffer) -11500 (clear-stream _test-output-stream) -11501 (clear-stream $_test-output-buffered-file->buffer) -11502 (clear-stream _test-error-stream) -11503 (clear-stream $_test-error-buffered-file->buffer) -11504 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11505 68/push 0/imm32 -11506 68/push 0/imm32 -11507 89/<- %edx 4/r32/esp -11508 (tailor-exit-descriptor %edx 0x10) -11509 # -11510 (write _test-input-stream "fn foo {\n") -11511 (write _test-input-stream " var a/eax: (addr stream int) <- copy 0\n") -11512 (write _test-input-stream " var b: boolean\n") -11513 (write _test-input-stream " write-to-stream a, b\n") -11514 (write _test-input-stream "}\n") -11515 # convert -11516 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11517 # registers except esp clobbered at this point -11518 # restore ed -11519 89/<- %edx 4/r32/esp -11520 (flush _test-output-buffered-file) -11521 (flush _test-error-buffered-file) -11522 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11528 # check output -11529 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-wrong-index-type: output should be empty") -11530 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: target 'b' must be an addr" "F - test-write-to-stream-with-wrong-index-type: error message") -11531 # check that stop(1) was called -11532 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-wrong-index-type: exit status") -11533 # don't restore from ebp -11534 81 0/subop/add %esp 8/imm32 -11535 # . epilogue -11536 5d/pop-to-ebp -11537 c3/return -11538 -11539 test-write-to-stream-with-no-inouts: -11540 # . prologue -11541 55/push-ebp -11542 89/<- %ebp 4/r32/esp -11543 # setup -11544 (clear-stream _test-input-stream) -11545 (clear-stream $_test-input-buffered-file->buffer) -11546 (clear-stream _test-output-stream) -11547 (clear-stream $_test-output-buffered-file->buffer) -11548 (clear-stream _test-error-stream) -11549 (clear-stream $_test-error-buffered-file->buffer) -11550 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11551 68/push 0/imm32 -11552 68/push 0/imm32 -11553 89/<- %edx 4/r32/esp -11554 (tailor-exit-descriptor %edx 0x10) -11555 # -11556 (write _test-input-stream "fn foo {\n") -11557 (write _test-input-stream " write-to-stream\n") -11558 (write _test-input-stream "}\n") -11559 # convert -11560 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11561 # registers except esp clobbered at this point -11562 # restore ed -11563 89/<- %edx 4/r32/esp -11564 (flush _test-output-buffered-file) -11565 (flush _test-error-buffered-file) -11566 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11572 # check output -11573 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-no-inouts: output should be empty") -11574 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: too few inouts (2 required)" "F - test-write-to-stream-with-no-inouts: error message") -11575 # check that stop(1) was called -11576 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-no-inouts: exit status") -11577 # don't restore from ebp -11578 81 0/subop/add %esp 8/imm32 -11579 # . epilogue -11580 5d/pop-to-ebp -11581 c3/return -11582 -11583 test-write-to-stream-with-too-few-inouts: -11584 # . prologue -11585 55/push-ebp -11586 89/<- %ebp 4/r32/esp -11587 # setup -11588 (clear-stream _test-input-stream) -11589 (clear-stream $_test-input-buffered-file->buffer) -11590 (clear-stream _test-output-stream) -11591 (clear-stream $_test-output-buffered-file->buffer) -11592 (clear-stream _test-error-stream) -11593 (clear-stream $_test-error-buffered-file->buffer) -11594 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11595 68/push 0/imm32 -11596 68/push 0/imm32 -11597 89/<- %edx 4/r32/esp -11598 (tailor-exit-descriptor %edx 0x10) -11599 # -11600 (write _test-input-stream "fn foo {\n") -11601 (write _test-input-stream " var a: (addr stream int)\n") -11602 (write _test-input-stream " write-to-stream a\n") -11603 (write _test-input-stream "}\n") -11604 # convert -11605 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11606 # registers except esp clobbered at this point -11607 # restore ed +11051 (tailor-exit-descriptor %edx 0x10) +11052 # +11053 (write _test-input-stream "fn foo {\n") +11054 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset\n") +11055 (write _test-input-stream "}\n") +11056 # convert +11057 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11058 # registers except esp clobbered at this point +11059 # restore ed +11060 89/<- %edx 4/r32/esp +11061 (flush _test-output-buffered-file) +11062 (flush _test-error-buffered-file) +11063 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11069 # check output +11070 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-no-inouts: output should be empty") +11071 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too few inouts (2 required)" "F - test-compute-offset-with-no-inouts: error message") +11072 # check that stop(1) was called +11073 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-no-inouts: exit status") +11074 # don't restore from ebp +11075 81 0/subop/add %esp 8/imm32 +11076 # . epilogue +11077 5d/pop-to-ebp +11078 c3/return +11079 +11080 test-compute-offset-with-too-few-inouts: +11081 # . prologue +11082 55/push-ebp +11083 89/<- %ebp 4/r32/esp +11084 # setup +11085 (clear-stream _test-input-stream) +11086 (clear-stream $_test-input-buffered-file->buffer) +11087 (clear-stream _test-output-stream) +11088 (clear-stream $_test-output-buffered-file->buffer) +11089 (clear-stream _test-error-stream) +11090 (clear-stream $_test-error-buffered-file->buffer) +11091 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11092 68/push 0/imm32 +11093 68/push 0/imm32 +11094 89/<- %edx 4/r32/esp +11095 (tailor-exit-descriptor %edx 0x10) +11096 # +11097 (write _test-input-stream "fn foo {\n") +11098 (write _test-input-stream " var a: (array int 3)\n") +11099 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a\n") +11100 (write _test-input-stream "}\n") +11101 # convert +11102 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11103 # registers except esp clobbered at this point +11104 # restore ed +11105 89/<- %edx 4/r32/esp +11106 (flush _test-output-buffered-file) +11107 (flush _test-error-buffered-file) +11108 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11114 # check output +11115 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-too-few-inouts: output should be empty") +11116 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too few inouts (2 required)" "F - test-compute-offset-with-too-few-inouts: error message") +11117 # check that stop(1) was called +11118 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-too-few-inouts: exit status") +11119 # don't restore from ebp +11120 81 0/subop/add %esp 8/imm32 +11121 # . epilogue +11122 5d/pop-to-ebp +11123 c3/return +11124 +11125 test-compute-offset-with-too-many-inouts: +11126 # . prologue +11127 55/push-ebp +11128 89/<- %ebp 4/r32/esp +11129 # setup +11130 (clear-stream _test-input-stream) +11131 (clear-stream $_test-input-buffered-file->buffer) +11132 (clear-stream _test-output-stream) +11133 (clear-stream $_test-output-buffered-file->buffer) +11134 (clear-stream _test-error-stream) +11135 (clear-stream $_test-error-buffered-file->buffer) +11136 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11137 68/push 0/imm32 +11138 68/push 0/imm32 +11139 89/<- %edx 4/r32/esp +11140 (tailor-exit-descriptor %edx 0x10) +11141 # +11142 (write _test-input-stream "fn foo {\n") +11143 (write _test-input-stream " var a: (array int 3)\n") +11144 (write _test-input-stream " var c/ecx: (offset int) <- compute-offset a, 0, 0\n") +11145 (write _test-input-stream "}\n") +11146 # convert +11147 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11148 # registers except esp clobbered at this point +11149 # restore ed +11150 89/<- %edx 4/r32/esp +11151 (flush _test-output-buffered-file) +11152 (flush _test-error-buffered-file) +11153 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11159 # check output +11160 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-too-many-inouts: output should be empty") +11161 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too many inouts (2 required)" "F - test-compute-offset-with-too-many-inouts: error message") +11162 # check that stop(1) was called +11163 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-too-many-inouts: exit status") +11164 # don't restore from ebp +11165 81 0/subop/add %esp 8/imm32 +11166 # . epilogue +11167 5d/pop-to-ebp +11168 c3/return +11169 +11170 test-compute-offset-with-no-output: +11171 # . prologue +11172 55/push-ebp +11173 89/<- %ebp 4/r32/esp +11174 # setup +11175 (clear-stream _test-input-stream) +11176 (clear-stream $_test-input-buffered-file->buffer) +11177 (clear-stream _test-output-stream) +11178 (clear-stream $_test-output-buffered-file->buffer) +11179 (clear-stream _test-error-stream) +11180 (clear-stream $_test-error-buffered-file->buffer) +11181 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11182 68/push 0/imm32 +11183 68/push 0/imm32 +11184 89/<- %edx 4/r32/esp +11185 (tailor-exit-descriptor %edx 0x10) +11186 # +11187 (write _test-input-stream "fn foo {\n") +11188 (write _test-input-stream " var a: (array int 3)\n") +11189 (write _test-input-stream " compute-offset a, 0\n") +11190 (write _test-input-stream "}\n") +11191 # convert +11192 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11193 # registers except esp clobbered at this point +11194 # restore ed +11195 89/<- %edx 4/r32/esp +11196 (flush _test-output-buffered-file) +11197 (flush _test-error-buffered-file) +11198 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11204 # check output +11205 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-no-output: output should be empty") +11206 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: must have an output" "F - test-compute-offset-with-no-output: error message") +11207 # check that stop(1) was called +11208 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-no-output: exit status") +11209 # don't restore from ebp +11210 81 0/subop/add %esp 8/imm32 +11211 # . epilogue +11212 5d/pop-to-ebp +11213 c3/return +11214 +11215 test-compute-offset-with-too-many-outputs: +11216 # . prologue +11217 55/push-ebp +11218 89/<- %ebp 4/r32/esp +11219 # setup +11220 (clear-stream _test-input-stream) +11221 (clear-stream $_test-input-buffered-file->buffer) +11222 (clear-stream _test-output-stream) +11223 (clear-stream $_test-output-buffered-file->buffer) +11224 (clear-stream _test-error-stream) +11225 (clear-stream $_test-error-buffered-file->buffer) +11226 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11227 68/push 0/imm32 +11228 68/push 0/imm32 +11229 89/<- %edx 4/r32/esp +11230 (tailor-exit-descriptor %edx 0x10) +11231 # +11232 (write _test-input-stream "fn foo {\n") +11233 (write _test-input-stream " var a: (array int 3)\n") +11234 (write _test-input-stream " var b/eax: (offset int) <- compute-offset a, 0\n") +11235 (write _test-input-stream " var c/ecx: (addr int) <- copy 0\n") +11236 (write _test-input-stream " b, c <- compute-offset a, 0\n") +11237 (write _test-input-stream "}\n") +11238 # convert +11239 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11240 # registers except esp clobbered at this point +11241 # restore ed +11242 89/<- %edx 4/r32/esp +11243 (flush _test-output-buffered-file) +11244 (flush _test-error-buffered-file) +11245 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11251 # check output +11252 (check-stream-equal _test-output-stream "" "F - test-compute-offset-with-too-many-outputs: output should be empty") +11253 (check-next-stream-line-equal _test-error-stream "fn foo: stmt compute-offset: too many outputs (1 required)" "F - test-compute-offset-with-too-many-outputs: error message") +11254 # check that stop(1) was called +11255 (check-ints-equal *(edx+4) 2 "F - test-compute-offset-with-too-many-outputs: exit status") +11256 # don't restore from ebp +11257 81 0/subop/add %esp 8/imm32 +11258 # . epilogue +11259 5d/pop-to-ebp +11260 c3/return +11261 +11262 test-convert-read-from-stream: +11263 # . prologue +11264 55/push-ebp +11265 89/<- %ebp 4/r32/esp +11266 # setup +11267 (clear-stream _test-input-stream) +11268 (clear-stream $_test-input-buffered-file->buffer) +11269 (clear-stream _test-output-stream) +11270 (clear-stream $_test-output-buffered-file->buffer) +11271 # +11272 (write _test-input-stream "fn foo {\n") +11273 (write _test-input-stream " var s/esi: (addr stream int) <- copy 0\n") +11274 (write _test-input-stream " var o/ecx: (addr int) <- copy 0\n") +11275 (write _test-input-stream " read-from-stream s, o\n") +11276 (write _test-input-stream "}\n") +11277 # convert +11278 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +11279 # registers except esp clobbered at this point +11280 # restore ed +11281 89/<- %edx 4/r32/esp +11282 (flush _test-output-buffered-file) +11283 (flush _test-error-buffered-file) +11284 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11290 # check output +11291 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-read-from-stream/0") +11292 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-read-from-stream/1") +11293 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-read-from-stream/2") +11294 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-read-from-stream/3") +11295 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-read-from-stream/4") +11296 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-read-from-stream/5") +11297 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-read-from-stream/6") +11298 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-read-from-stream/7") +11299 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-read-from-stream/8") +11300 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-read-from-stream/9") +11301 (check-next-stream-line-equal _test-output-stream " (read-from-stream %esi %ecx 0x00000004)" "F - test-convert-read-from-stream/10") +11302 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-read-from-stream/11") +11303 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-read-from-stream/12") +11304 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-read-from-stream/13") +11305 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-read-from-stream/14") +11306 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-read-from-stream/15") +11307 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-read-from-stream/16") +11308 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-read-from-stream/17") +11309 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-read-from-stream/18") +11310 # . epilogue +11311 89/<- %esp 5/r32/ebp +11312 5d/pop-to-ebp +11313 c3/return +11314 +11315 test-convert-read-from-stream-with-correct-payload-size: +11316 # . prologue +11317 55/push-ebp +11318 89/<- %ebp 4/r32/esp +11319 # setup +11320 (clear-stream _test-input-stream) +11321 (clear-stream $_test-input-buffered-file->buffer) +11322 (clear-stream _test-output-stream) +11323 (clear-stream $_test-output-buffered-file->buffer) +11324 # +11325 (write _test-input-stream "fn foo {\n") +11326 (write _test-input-stream " var s/esi: (addr stream handle int) <- copy 0\n") +11327 (write _test-input-stream " var o/ecx: (addr handle int) <- copy 0\n") +11328 (write _test-input-stream " read-from-stream s, o\n") +11329 (write _test-input-stream "}\n") +11330 # convert +11331 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +11332 # registers except esp clobbered at this point +11333 # restore ed +11334 89/<- %edx 4/r32/esp +11335 (flush _test-output-buffered-file) +11336 (flush _test-error-buffered-file) +11337 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11343 # check output +11344 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-read-from-stream-with-correct-payload-size/0") +11345 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-read-from-stream-with-correct-payload-size/1") +11346 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-read-from-stream-with-correct-payload-size/2") +11347 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-read-from-stream-with-correct-payload-size/3") +11348 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-read-from-stream-with-correct-payload-size/4") +11349 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-read-from-stream-with-correct-payload-size/5") +11350 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-read-from-stream-with-correct-payload-size/6") +11351 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-read-from-stream-with-correct-payload-size/7") +11352 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-read-from-stream-with-correct-payload-size/8") +11353 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-read-from-stream-with-correct-payload-size/9") +11354 (check-next-stream-line-equal _test-output-stream " (read-from-stream %esi %ecx 0x00000008)" "F - test-convert-read-from-stream-with-correct-payload-size/10") +11355 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-read-from-stream-with-correct-payload-size/11") +11356 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-read-from-stream-with-correct-payload-size/12") +11357 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-read-from-stream-with-correct-payload-size/13") +11358 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-read-from-stream-with-correct-payload-size/14") +11359 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-read-from-stream-with-correct-payload-size/15") +11360 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-read-from-stream-with-correct-payload-size/16") +11361 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-read-from-stream-with-correct-payload-size/17") +11362 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-read-from-stream-with-correct-payload-size/18") +11363 # . epilogue +11364 89/<- %esp 5/r32/ebp +11365 5d/pop-to-ebp +11366 c3/return +11367 +11368 test-read-from-stream-with-non-stream-atom-base-type: +11369 # . prologue +11370 55/push-ebp +11371 89/<- %ebp 4/r32/esp +11372 # setup +11373 (clear-stream _test-input-stream) +11374 (clear-stream $_test-input-buffered-file->buffer) +11375 (clear-stream _test-output-stream) +11376 (clear-stream $_test-output-buffered-file->buffer) +11377 (clear-stream _test-error-stream) +11378 (clear-stream $_test-error-buffered-file->buffer) +11379 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11380 68/push 0/imm32 +11381 68/push 0/imm32 +11382 89/<- %edx 4/r32/esp +11383 (tailor-exit-descriptor %edx 0x10) +11384 # +11385 (write _test-input-stream "fn foo {\n") +11386 (write _test-input-stream " var a: int\n") +11387 (write _test-input-stream " read-from-stream a, 0\n") +11388 (write _test-input-stream "}\n") +11389 # convert +11390 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11391 # registers except esp clobbered at this point +11392 # restore ed +11393 89/<- %edx 4/r32/esp +11394 (flush _test-output-buffered-file) +11395 (flush _test-error-buffered-file) +11396 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11402 # check output +11403 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-non-stream-atom-base-type: output should be empty") +11404 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-non-stream-atom-base-type: error message") +11405 # check that stop(1) was called +11406 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-non-stream-atom-base-type: exit status") +11407 # don't restore from ebp +11408 81 0/subop/add %esp 8/imm32 +11409 # . epilogue +11410 5d/pop-to-ebp +11411 c3/return +11412 +11413 test-read-from-stream-with-non-stream-compound-base-type: +11414 # . prologue +11415 55/push-ebp +11416 89/<- %ebp 4/r32/esp +11417 # setup +11418 (clear-stream _test-input-stream) +11419 (clear-stream $_test-input-buffered-file->buffer) +11420 (clear-stream _test-output-stream) +11421 (clear-stream $_test-output-buffered-file->buffer) +11422 (clear-stream _test-error-stream) +11423 (clear-stream $_test-error-buffered-file->buffer) +11424 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11425 68/push 0/imm32 +11426 68/push 0/imm32 +11427 89/<- %edx 4/r32/esp +11428 (tailor-exit-descriptor %edx 0x10) +11429 # +11430 (write _test-input-stream "fn foo {\n") +11431 (write _test-input-stream " var a: (handle int)\n") +11432 (write _test-input-stream " read-from-stream a, 0\n") +11433 (write _test-input-stream "}\n") +11434 # convert +11435 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11436 # registers except esp clobbered at this point +11437 # restore ed +11438 89/<- %edx 4/r32/esp +11439 (flush _test-output-buffered-file) +11440 (flush _test-error-buffered-file) +11441 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11447 # check output +11448 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-non-stream-compound-base-type: output should be empty") +11449 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-non-stream-compound-base-type: error message") +11450 # check that stop(1) was called +11451 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-non-stream-compound-base-type: exit status") +11452 # don't restore from ebp +11453 81 0/subop/add %esp 8/imm32 +11454 # . epilogue +11455 5d/pop-to-ebp +11456 c3/return +11457 +11458 test-read-from-stream-with-non-stream-compound-base-type-2: +11459 # . prologue +11460 55/push-ebp +11461 89/<- %ebp 4/r32/esp +11462 # setup +11463 (clear-stream _test-input-stream) +11464 (clear-stream $_test-input-buffered-file->buffer) +11465 (clear-stream _test-output-stream) +11466 (clear-stream $_test-output-buffered-file->buffer) +11467 (clear-stream _test-error-stream) +11468 (clear-stream $_test-error-buffered-file->buffer) +11469 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11470 68/push 0/imm32 +11471 68/push 0/imm32 +11472 89/<- %edx 4/r32/esp +11473 (tailor-exit-descriptor %edx 0x10) +11474 # +11475 (write _test-input-stream "fn foo {\n") +11476 (write _test-input-stream " var a: (addr int)\n") +11477 (write _test-input-stream " read-from-stream a, 0\n") +11478 (write _test-input-stream "}\n") +11479 # convert +11480 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11481 # registers except esp clobbered at this point +11482 # restore ed +11483 89/<- %edx 4/r32/esp +11484 (flush _test-output-buffered-file) +11485 (flush _test-error-buffered-file) +11486 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11492 # check output +11493 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-non-stream-compound-base-type-2: output should be empty") +11494 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-non-stream-compound-base-type-2: error message") +11495 # check that stop(1) was called +11496 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-non-stream-compound-base-type-2: exit status") +11497 # don't restore from ebp +11498 81 0/subop/add %esp 8/imm32 +11499 # . epilogue +11500 5d/pop-to-ebp +11501 c3/return +11502 +11503 test-read-from-stream-with-stream-atom-base-type: +11504 # . prologue +11505 55/push-ebp +11506 89/<- %ebp 4/r32/esp +11507 # setup +11508 (clear-stream _test-input-stream) +11509 (clear-stream $_test-input-buffered-file->buffer) +11510 (clear-stream _test-output-stream) +11511 (clear-stream $_test-output-buffered-file->buffer) +11512 (clear-stream _test-error-stream) +11513 (clear-stream $_test-error-buffered-file->buffer) +11514 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11515 68/push 0/imm32 +11516 68/push 0/imm32 +11517 89/<- %edx 4/r32/esp +11518 (tailor-exit-descriptor %edx 0x10) +11519 # +11520 (write _test-input-stream "fn foo {\n") +11521 (write _test-input-stream " var a: stream\n") +11522 (write _test-input-stream " read-from-stream a, 0\n") +11523 (write _test-input-stream "}\n") +11524 # convert +11525 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11526 # registers except esp clobbered at this point +11527 # restore ed +11528 89/<- %edx 4/r32/esp +11529 (flush _test-output-buffered-file) +11530 (flush _test-error-buffered-file) +11531 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11537 # check output +11538 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-stream-atom-base-type: output should be empty") +11539 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: var 'a' must be an addr to a stream" "F - test-read-from-stream-with-stream-atom-base-type: error message") +11540 # check that stop(1) was called +11541 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-stream-atom-base-type: exit status") +11542 # don't restore from ebp +11543 81 0/subop/add %esp 8/imm32 +11544 # . epilogue +11545 5d/pop-to-ebp +11546 c3/return +11547 +11548 test-read-from-stream-with-wrong-index-type: +11549 # . prologue +11550 55/push-ebp +11551 89/<- %ebp 4/r32/esp +11552 # setup +11553 (clear-stream _test-input-stream) +11554 (clear-stream $_test-input-buffered-file->buffer) +11555 (clear-stream _test-output-stream) +11556 (clear-stream $_test-output-buffered-file->buffer) +11557 (clear-stream _test-error-stream) +11558 (clear-stream $_test-error-buffered-file->buffer) +11559 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11560 68/push 0/imm32 +11561 68/push 0/imm32 +11562 89/<- %edx 4/r32/esp +11563 (tailor-exit-descriptor %edx 0x10) +11564 # +11565 (write _test-input-stream "fn foo {\n") +11566 (write _test-input-stream " var a/eax: (addr stream int) <- copy 0\n") +11567 (write _test-input-stream " var b: boolean\n") +11568 (write _test-input-stream " read-from-stream a, b\n") +11569 (write _test-input-stream "}\n") +11570 # convert +11571 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11572 # registers except esp clobbered at this point +11573 # restore ed +11574 89/<- %edx 4/r32/esp +11575 (flush _test-output-buffered-file) +11576 (flush _test-error-buffered-file) +11577 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11583 # check output +11584 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-wrong-index-type: output should be empty") +11585 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: target 'b' must be an addr" "F - test-read-from-stream-with-wrong-index-type: error message") +11586 # check that stop(1) was called +11587 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-wrong-index-type: exit status") +11588 # don't restore from ebp +11589 81 0/subop/add %esp 8/imm32 +11590 # . epilogue +11591 5d/pop-to-ebp +11592 c3/return +11593 +11594 test-read-from-stream-with-no-inouts: +11595 # . prologue +11596 55/push-ebp +11597 89/<- %ebp 4/r32/esp +11598 # setup +11599 (clear-stream _test-input-stream) +11600 (clear-stream $_test-input-buffered-file->buffer) +11601 (clear-stream _test-output-stream) +11602 (clear-stream $_test-output-buffered-file->buffer) +11603 (clear-stream _test-error-stream) +11604 (clear-stream $_test-error-buffered-file->buffer) +11605 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11606 68/push 0/imm32 +11607 68/push 0/imm32 11608 89/<- %edx 4/r32/esp -11609 (flush _test-output-buffered-file) -11610 (flush _test-error-buffered-file) -11611 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11617 # check output -11618 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-too-few-inouts: output should be empty") -11619 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: too few inouts (2 required)" "F - test-write-to-stream-with-too-few-inouts: error message") -11620 # check that stop(1) was called -11621 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-too-few-inouts: exit status") -11622 # don't restore from ebp -11623 81 0/subop/add %esp 8/imm32 -11624 # . epilogue -11625 5d/pop-to-ebp -11626 c3/return -11627 -11628 test-write-to-stream-with-too-many-inouts: -11629 # . prologue -11630 55/push-ebp -11631 89/<- %ebp 4/r32/esp -11632 # setup -11633 (clear-stream _test-input-stream) -11634 (clear-stream $_test-input-buffered-file->buffer) -11635 (clear-stream _test-output-stream) -11636 (clear-stream $_test-output-buffered-file->buffer) -11637 (clear-stream _test-error-stream) -11638 (clear-stream $_test-error-buffered-file->buffer) -11639 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11640 68/push 0/imm32 -11641 68/push 0/imm32 -11642 89/<- %edx 4/r32/esp -11643 (tailor-exit-descriptor %edx 0x10) -11644 # -11645 (write _test-input-stream "fn foo {\n") -11646 (write _test-input-stream " var a: (addr stream int)\n") -11647 (write _test-input-stream " var b: (addr int)\n") -11648 (write _test-input-stream " write-to-stream a, b, 0\n") -11649 (write _test-input-stream "}\n") -11650 # convert -11651 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11652 # registers except esp clobbered at this point -11653 # restore ed -11654 89/<- %edx 4/r32/esp -11655 (flush _test-output-buffered-file) -11656 (flush _test-error-buffered-file) -11657 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11663 # check output -11664 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-too-many-inouts: output should be empty") -11665 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: too many inouts (2 required)" "F - test-write-to-stream-with-too-many-inouts: error message") -11666 # check that stop(1) was called -11667 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-too-many-inouts: exit status") -11668 # don't restore from ebp -11669 81 0/subop/add %esp 8/imm32 -11670 # . epilogue -11671 5d/pop-to-ebp -11672 c3/return -11673 -11674 test-write-to-stream-with-output: -11675 # . prologue -11676 55/push-ebp -11677 89/<- %ebp 4/r32/esp -11678 # setup -11679 (clear-stream _test-input-stream) -11680 (clear-stream $_test-input-buffered-file->buffer) -11681 (clear-stream _test-output-stream) -11682 (clear-stream $_test-output-buffered-file->buffer) -11683 (clear-stream _test-error-stream) -11684 (clear-stream $_test-error-buffered-file->buffer) -11685 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11686 68/push 0/imm32 -11687 68/push 0/imm32 -11688 89/<- %edx 4/r32/esp -11689 (tailor-exit-descriptor %edx 0x10) -11690 # -11691 (write _test-input-stream "fn foo {\n") -11692 (write _test-input-stream " var a: (addr stream int)\n") -11693 (write _test-input-stream " var b/eax: (addr int) <- copy 0\n") -11694 (write _test-input-stream " b <- write-to-stream a, b\n") -11695 (write _test-input-stream "}\n") -11696 # convert -11697 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11698 # registers except esp clobbered at this point -11699 # restore ed -11700 89/<- %edx 4/r32/esp -11701 (flush _test-output-buffered-file) -11702 (flush _test-error-buffered-file) -11703 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11709 # check output -11710 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-output: output should be empty") -11711 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: unexpected output" "F - test-write-to-stream-with-output: error message") -11712 # check that stop(1) was called -11713 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-output: exit status") -11714 # don't restore from ebp -11715 81 0/subop/add %esp 8/imm32 -11716 # . epilogue -11717 5d/pop-to-ebp -11718 c3/return -11719 -11720 test-length-with-non-array-atom-base-type: -11721 # . prologue -11722 55/push-ebp -11723 89/<- %ebp 4/r32/esp -11724 # setup -11725 (clear-stream _test-input-stream) -11726 (clear-stream $_test-input-buffered-file->buffer) -11727 (clear-stream _test-output-stream) -11728 (clear-stream $_test-output-buffered-file->buffer) -11729 (clear-stream _test-error-stream) -11730 (clear-stream $_test-error-buffered-file->buffer) -11731 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11732 68/push 0/imm32 -11733 68/push 0/imm32 -11734 89/<- %edx 4/r32/esp -11735 (tailor-exit-descriptor %edx 0x10) -11736 # -11737 (write _test-input-stream "fn foo {\n") -11738 (write _test-input-stream " var a: int\n") -11739 (write _test-input-stream " var c/ecx: int <- length a\n") -11740 (write _test-input-stream "}\n") -11741 # convert -11742 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11743 # registers except esp clobbered at this point -11744 # restore ed -11745 89/<- %edx 4/r32/esp -11746 (flush _test-output-buffered-file) -11747 (flush _test-error-buffered-file) -11748 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11754 # check output -11755 (check-stream-equal _test-output-stream "" "F - test-length-with-non-array-atom-base-type: output should be empty") -11756 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is not an array" "F - test-length-with-non-array-atom-base-type: error message") -11757 # check that stop(1) was called -11758 (check-ints-equal *(edx+4) 2 "F - test-length-with-non-array-atom-base-type: exit status") -11759 # don't restore from ebp -11760 81 0/subop/add %esp 8/imm32 -11761 # . epilogue -11762 5d/pop-to-ebp -11763 c3/return -11764 -11765 test-length-with-non-array-compound-base-type: -11766 # . prologue -11767 55/push-ebp -11768 89/<- %ebp 4/r32/esp -11769 # setup -11770 (clear-stream _test-input-stream) -11771 (clear-stream $_test-input-buffered-file->buffer) -11772 (clear-stream _test-output-stream) -11773 (clear-stream $_test-output-buffered-file->buffer) -11774 (clear-stream _test-error-stream) -11775 (clear-stream $_test-error-buffered-file->buffer) -11776 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11777 68/push 0/imm32 -11778 68/push 0/imm32 -11779 89/<- %edx 4/r32/esp -11780 (tailor-exit-descriptor %edx 0x10) -11781 # -11782 (write _test-input-stream "fn foo {\n") -11783 (write _test-input-stream " var a: (handle int)\n") -11784 (write _test-input-stream " var c/ecx: (addr int) <- length a, 0\n") -11785 (write _test-input-stream "}\n") -11786 # convert -11787 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11788 # registers except esp clobbered at this point -11789 # restore ed -11790 89/<- %edx 4/r32/esp -11791 (flush _test-output-buffered-file) -11792 (flush _test-error-buffered-file) -11793 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11799 # check output -11800 (check-stream-equal _test-output-stream "" "F - test-length-with-non-array-compound-base-type: output should be empty") -11801 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is not an array" "F - test-length-with-non-array-compound-base-type: error message") -11802 # check that stop(1) was called -11803 (check-ints-equal *(edx+4) 2 "F - test-length-with-non-array-compound-base-type: exit status") -11804 # don't restore from ebp -11805 81 0/subop/add %esp 8/imm32 -11806 # . epilogue -11807 5d/pop-to-ebp -11808 c3/return -11809 -11810 test-length-with-non-array-compound-base-type-2: -11811 # . prologue -11812 55/push-ebp -11813 89/<- %ebp 4/r32/esp -11814 # setup -11815 (clear-stream _test-input-stream) -11816 (clear-stream $_test-input-buffered-file->buffer) -11817 (clear-stream _test-output-stream) -11818 (clear-stream $_test-output-buffered-file->buffer) -11819 (clear-stream _test-error-stream) -11820 (clear-stream $_test-error-buffered-file->buffer) -11821 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11822 68/push 0/imm32 -11823 68/push 0/imm32 -11824 89/<- %edx 4/r32/esp -11825 (tailor-exit-descriptor %edx 0x10) -11826 # -11827 (write _test-input-stream "fn foo {\n") -11828 (write _test-input-stream " var a: (addr int)\n") -11829 (write _test-input-stream " var c/ecx: (addr int) <- length a, 0\n") -11830 (write _test-input-stream "}\n") -11831 # convert -11832 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11833 # registers except esp clobbered at this point -11834 # restore ed -11835 89/<- %edx 4/r32/esp -11836 (flush _test-output-buffered-file) -11837 (flush _test-error-buffered-file) -11838 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11844 # check output -11845 (check-stream-equal _test-output-stream "" "F - test-length-with-non-array-compound-base-type-2: output should be empty") -11846 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is not an array" "F - test-length-with-non-array-compound-base-type-2: error message") -11847 # check that stop(1) was called -11848 (check-ints-equal *(edx+4) 2 "F - test-length-with-non-array-compound-base-type-2: exit status") -11849 # don't restore from ebp -11850 81 0/subop/add %esp 8/imm32 -11851 # . epilogue -11852 5d/pop-to-ebp -11853 c3/return -11854 -11855 test-length-with-array-atom-base-type: -11856 # . prologue -11857 55/push-ebp -11858 89/<- %ebp 4/r32/esp -11859 # setup -11860 (clear-stream _test-input-stream) -11861 (clear-stream $_test-input-buffered-file->buffer) -11862 (clear-stream _test-output-stream) -11863 (clear-stream $_test-output-buffered-file->buffer) -11864 (clear-stream _test-error-stream) -11865 (clear-stream $_test-error-buffered-file->buffer) -11866 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11867 68/push 0/imm32 -11868 68/push 0/imm32 -11869 89/<- %edx 4/r32/esp -11870 (tailor-exit-descriptor %edx 0x10) -11871 # -11872 (write _test-input-stream "fn foo {\n") -11873 (write _test-input-stream " var a: array\n") -11874 (write _test-input-stream " var c/ecx: (addr int) <- length a\n") -11875 (write _test-input-stream "}\n") -11876 # convert -11877 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11878 # registers except esp clobbered at this point -11879 # restore ed -11880 89/<- %edx 4/r32/esp -11881 (flush _test-output-buffered-file) -11882 (flush _test-error-buffered-file) -11883 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11889 # check output -11890 (check-stream-equal _test-output-stream "" "F - test-length-with-array-atom-base-type: output should be empty") -11891 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: array 'a' must specify the type of its elements" "F - test-length-with-array-atom-base-type: error message") -11892 # check that stop(1) was called -11893 (check-ints-equal *(edx+4) 2 "F - test-length-with-array-atom-base-type: exit status") -11894 # don't restore from ebp -11895 81 0/subop/add %esp 8/imm32 -11896 # . epilogue -11897 5d/pop-to-ebp -11898 c3/return -11899 -11900 test-length-with-addr-base-on-stack: -11901 # . prologue -11902 55/push-ebp -11903 89/<- %ebp 4/r32/esp -11904 # setup -11905 (clear-stream _test-input-stream) -11906 (clear-stream $_test-input-buffered-file->buffer) -11907 (clear-stream _test-output-stream) -11908 (clear-stream $_test-output-buffered-file->buffer) -11909 (clear-stream _test-error-stream) -11910 (clear-stream $_test-error-buffered-file->buffer) -11911 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11912 68/push 0/imm32 -11913 68/push 0/imm32 -11914 89/<- %edx 4/r32/esp -11915 (tailor-exit-descriptor %edx 0x10) -11916 # -11917 (write _test-input-stream "fn foo {\n") -11918 (write _test-input-stream " var a: (addr array int)\n") -11919 (write _test-input-stream " var c/ecx: (addr int) <- length a\n") -11920 (write _test-input-stream "}\n") -11921 # convert -11922 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11923 # registers except esp clobbered at this point -11924 # restore ed -11925 89/<- %edx 4/r32/esp -11926 (flush _test-output-buffered-file) -11927 (flush _test-error-buffered-file) -11928 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11934 # check output -11935 (check-stream-equal _test-output-stream "" "F - test-length-with-addr-base-on-stack: output should be empty") -11936 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is an addr to an array, and so must live in a register" "F - test-length-with-addr-base-on-stack: error message") -11937 # check that stop(1) was called -11938 (check-ints-equal *(edx+4) 2 "F - test-length-with-addr-base-on-stack: exit status") -11939 # don't restore from ebp -11940 81 0/subop/add %esp 8/imm32 -11941 # . epilogue -11942 5d/pop-to-ebp -11943 c3/return -11944 -11945 test-length-with-wrong-output-type: -11946 # . prologue -11947 55/push-ebp -11948 89/<- %ebp 4/r32/esp -11949 # setup -11950 (clear-stream _test-input-stream) -11951 (clear-stream $_test-input-buffered-file->buffer) -11952 (clear-stream _test-output-stream) -11953 (clear-stream $_test-output-buffered-file->buffer) -11954 (clear-stream _test-error-stream) -11955 (clear-stream $_test-error-buffered-file->buffer) -11956 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -11957 68/push 0/imm32 -11958 68/push 0/imm32 -11959 89/<- %edx 4/r32/esp -11960 (tailor-exit-descriptor %edx 0x10) -11961 # -11962 (write _test-input-stream "fn foo {\n") -11963 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") -11964 (write _test-input-stream " var o/edi: (addr int) <- length a\n") -11965 (write _test-input-stream "}\n") -11966 # convert -11967 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -11968 # registers except esp clobbered at this point -11969 # restore ed -11970 89/<- %edx 4/r32/esp -11971 (flush _test-output-buffered-file) -11972 (flush _test-error-buffered-file) -11973 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -11979 # check output -11980 (check-stream-equal _test-output-stream "" "F - test-length-with-wrong-output-type: output should be empty") -11981 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: output 'o' does not have the right type" "F - test-length-with-wrong-output-type: error message") -11982 # check that stop(1) was called -11983 (check-ints-equal *(edx+4) 2 "F - test-length-with-wrong-output-type: exit status") -11984 # don't restore from ebp -11985 81 0/subop/add %esp 8/imm32 -11986 # . epilogue -11987 5d/pop-to-ebp -11988 c3/return -11989 -11990 test-length-with-wrong-output-compound-type: -11991 # . prologue -11992 55/push-ebp -11993 89/<- %ebp 4/r32/esp -11994 # setup -11995 (clear-stream _test-input-stream) -11996 (clear-stream $_test-input-buffered-file->buffer) -11997 (clear-stream _test-output-stream) -11998 (clear-stream $_test-output-buffered-file->buffer) -11999 (clear-stream _test-error-stream) -12000 (clear-stream $_test-error-buffered-file->buffer) -12001 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12002 68/push 0/imm32 -12003 68/push 0/imm32 -12004 89/<- %edx 4/r32/esp -12005 (tailor-exit-descriptor %edx 0x10) -12006 # -12007 (write _test-input-stream "fn foo {\n") -12008 (write _test-input-stream " var a/ebx: (addr array handle boolean) <- copy 0\n") -12009 (write _test-input-stream " var o/edi: (addr handle int) <- length a\n") -12010 (write _test-input-stream "}\n") -12011 # convert -12012 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12013 # registers except esp clobbered at this point -12014 # restore ed -12015 89/<- %edx 4/r32/esp -12016 (flush _test-output-buffered-file) -12017 (flush _test-error-buffered-file) -12018 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12024 # check output -12025 (check-stream-equal _test-output-stream "" "F - test-length-with-wrong-output-compound-type: output should be empty") -12026 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: output 'o' does not have the right type" "F - test-length-with-wrong-output-compound-type: error message") -12027 # check that stop(1) was called -12028 (check-ints-equal *(edx+4) 2 "F - test-length-with-wrong-output-compound-type: exit status") -12029 # don't restore from ebp -12030 81 0/subop/add %esp 8/imm32 -12031 # . epilogue -12032 5d/pop-to-ebp -12033 c3/return -12034 -12035 test-length-with-no-inouts: -12036 # . prologue -12037 55/push-ebp -12038 89/<- %ebp 4/r32/esp -12039 # setup -12040 (clear-stream _test-input-stream) -12041 (clear-stream $_test-input-buffered-file->buffer) -12042 (clear-stream _test-output-stream) -12043 (clear-stream $_test-output-buffered-file->buffer) -12044 (clear-stream _test-error-stream) -12045 (clear-stream $_test-error-buffered-file->buffer) -12046 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12047 68/push 0/imm32 -12048 68/push 0/imm32 -12049 89/<- %edx 4/r32/esp -12050 (tailor-exit-descriptor %edx 0x10) -12051 # -12052 (write _test-input-stream "fn foo {\n") -12053 (write _test-input-stream " var c/ecx: int <- length\n") -12054 (write _test-input-stream "}\n") -12055 # convert -12056 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12057 # registers except esp clobbered at this point -12058 # restore ed -12059 89/<- %edx 4/r32/esp -12060 (flush _test-output-buffered-file) -12061 (flush _test-error-buffered-file) -12062 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12068 # check output -12069 (check-stream-equal _test-output-stream "" "F - test-length-with-no-inouts: output should be empty") -12070 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: too few inouts (1 required)" "F - test-length-with-no-inouts: error message") -12071 # check that stop(1) was called -12072 (check-ints-equal *(edx+4) 2 "F - test-length-with-no-inouts: exit status") -12073 # don't restore from ebp -12074 81 0/subop/add %esp 8/imm32 -12075 # . epilogue -12076 5d/pop-to-ebp -12077 c3/return -12078 -12079 test-length-with-too-many-inouts: -12080 # . prologue -12081 55/push-ebp -12082 89/<- %ebp 4/r32/esp -12083 # setup -12084 (clear-stream _test-input-stream) -12085 (clear-stream $_test-input-buffered-file->buffer) -12086 (clear-stream _test-output-stream) -12087 (clear-stream $_test-output-buffered-file->buffer) -12088 (clear-stream _test-error-stream) -12089 (clear-stream $_test-error-buffered-file->buffer) -12090 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12091 68/push 0/imm32 -12092 68/push 0/imm32 -12093 89/<- %edx 4/r32/esp -12094 (tailor-exit-descriptor %edx 0x10) -12095 # -12096 (write _test-input-stream "fn foo {\n") -12097 (write _test-input-stream " var a: (array int 3)\n") -12098 (write _test-input-stream " var c/ecx: int <- length a, 0, 0\n") -12099 (write _test-input-stream "}\n") -12100 # convert -12101 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12102 # registers except esp clobbered at this point -12103 # restore ed -12104 89/<- %edx 4/r32/esp -12105 (flush _test-output-buffered-file) -12106 (flush _test-error-buffered-file) -12107 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12113 # check output -12114 (check-stream-equal _test-output-stream "" "F - test-length-with-too-many-inouts: output should be empty") -12115 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: too many inouts (1 required)" "F - test-length-with-too-many-inouts: error message") -12116 # check that stop(1) was called -12117 (check-ints-equal *(edx+4) 2 "F - test-length-with-too-many-inouts: exit status") -12118 # don't restore from ebp -12119 81 0/subop/add %esp 8/imm32 -12120 # . epilogue -12121 5d/pop-to-ebp -12122 c3/return -12123 -12124 test-length-with-no-output: -12125 # . prologue -12126 55/push-ebp -12127 89/<- %ebp 4/r32/esp -12128 # setup -12129 (clear-stream _test-input-stream) -12130 (clear-stream $_test-input-buffered-file->buffer) -12131 (clear-stream _test-output-stream) -12132 (clear-stream $_test-output-buffered-file->buffer) -12133 (clear-stream _test-error-stream) -12134 (clear-stream $_test-error-buffered-file->buffer) -12135 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12136 68/push 0/imm32 -12137 68/push 0/imm32 -12138 89/<- %edx 4/r32/esp -12139 (tailor-exit-descriptor %edx 0x10) -12140 # -12141 (write _test-input-stream "fn foo {\n") -12142 (write _test-input-stream " var a: (array int 3)\n") -12143 (write _test-input-stream " length a\n") -12144 (write _test-input-stream "}\n") -12145 # convert -12146 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12147 # registers except esp clobbered at this point -12148 # restore ed -12149 89/<- %edx 4/r32/esp -12150 (flush _test-output-buffered-file) -12151 (flush _test-error-buffered-file) -12152 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12158 # check output -12159 (check-stream-equal _test-output-stream "" "F - test-length-with-no-output: output should be empty") -12160 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: must have an output" "F - test-length-with-no-output: error message") -12161 # check that stop(1) was called -12162 (check-ints-equal *(edx+4) 2 "F - test-length-with-no-output: exit status") -12163 # don't restore from ebp -12164 81 0/subop/add %esp 8/imm32 -12165 # . epilogue -12166 5d/pop-to-ebp -12167 c3/return -12168 -12169 test-length-with-too-many-outputs: -12170 # . prologue -12171 55/push-ebp -12172 89/<- %ebp 4/r32/esp -12173 # setup -12174 (clear-stream _test-input-stream) -12175 (clear-stream $_test-input-buffered-file->buffer) -12176 (clear-stream _test-output-stream) -12177 (clear-stream $_test-output-buffered-file->buffer) -12178 (clear-stream _test-error-stream) -12179 (clear-stream $_test-error-buffered-file->buffer) -12180 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12181 68/push 0/imm32 -12182 68/push 0/imm32 -12183 89/<- %edx 4/r32/esp -12184 (tailor-exit-descriptor %edx 0x10) -12185 # -12186 (write _test-input-stream "fn foo {\n") -12187 (write _test-input-stream " var a: (array int 3)\n") -12188 (write _test-input-stream " var b/eax: int <- copy 0\n") -12189 (write _test-input-stream " var c/ecx: int <- copy 0\n") -12190 (write _test-input-stream " b, c <- length a\n") -12191 (write _test-input-stream "}\n") -12192 # convert -12193 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12194 # registers except esp clobbered at this point -12195 # restore ed -12196 89/<- %edx 4/r32/esp -12197 (flush _test-output-buffered-file) -12198 (flush _test-error-buffered-file) -12199 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12205 # check output -12206 (check-stream-equal _test-output-stream "" "F - test-length-with-too-many-outputs: output should be empty") -12207 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: too many outputs (1 required)" "F - test-length-with-too-many-outputs: error message") -12208 # check that stop(1) was called -12209 (check-ints-equal *(edx+4) 2 "F - test-length-with-too-many-outputs: exit status") -12210 # don't restore from ebp -12211 81 0/subop/add %esp 8/imm32 -12212 # . epilogue -12213 5d/pop-to-ebp -12214 c3/return -12215 -12216 test-convert-function-with-return-register-and-local: -12217 # . prologue -12218 55/push-ebp -12219 89/<- %ebp 4/r32/esp -12220 # setup -12221 (clear-stream _test-input-stream) -12222 (clear-stream $_test-input-buffered-file->buffer) -12223 (clear-stream _test-output-stream) -12224 (clear-stream $_test-output-buffered-file->buffer) -12225 # -12226 (write _test-input-stream "fn foo -> _/eax: int {\n") -12227 (write _test-input-stream " var y/eax: int <- copy 3\n") -12228 (write _test-input-stream " var z/ecx: int <- copy 4\n") -12229 (write _test-input-stream " return y\n") -12230 (write _test-input-stream "}\n") -12231 # convert -12232 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -12233 (flush _test-output-buffered-file) -12234 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12240 # check output -12241 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-register-and-local/0") -12242 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-register-and-local/1") -12243 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-register-and-local/2") -12244 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-register-and-local/3") -12245 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-register-and-local/4") -12246 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-register-and-local/5") -12247 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-register-and-local/6") -12248 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-register-and-local/7") -12249 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-return-register-and-local/8") -12250 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-convert-function-with-return-register-and-local/9") -12251 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-with-return-register-and-local/10") -12252 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-return-register-and-local/11") -12253 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-return-register-and-local/12") -12254 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-register-and-local/13") -12255 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-register-and-local/14") -12256 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-register-and-local/15") -12257 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-register-and-local/16") -12258 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-register-and-local/17") -12259 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-register-and-local/18") -12260 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-register-and-local/19") -12261 # . epilogue -12262 89/<- %esp 5/r32/ebp -12263 5d/pop-to-ebp -12264 c3/return -12265 -12266 test-convert-function-with-return-register-and-local-2: -12267 # . prologue -12268 55/push-ebp -12269 89/<- %ebp 4/r32/esp -12270 # setup -12271 (clear-stream _test-input-stream) -12272 (clear-stream $_test-input-buffered-file->buffer) -12273 (clear-stream _test-output-stream) -12274 (clear-stream $_test-output-buffered-file->buffer) -12275 # -12276 (write _test-input-stream "fn foo -> _/eax: int {\n") -12277 (write _test-input-stream " var y/eax: int <- copy 3\n") -12278 (write _test-input-stream " var z/ecx: int <- copy 4\n") -12279 (write _test-input-stream " return z\n") -12280 (write _test-input-stream "}\n") -12281 # convert -12282 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -12283 (flush _test-output-buffered-file) -12284 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12290 # check output -12291 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-register-and-local-2/0") -12292 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-register-and-local-2/1") -12293 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-register-and-local-2/2") -12294 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-register-and-local-2/3") -12295 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-register-and-local-2/4") -12296 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-register-and-local-2/5") -12297 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-register-and-local-2/6") -12298 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-register-and-local-2/7") -12299 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-return-register-and-local-2/8") -12300 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-convert-function-with-return-register-and-local-2/9") -12301 (check-next-stream-line-equal _test-output-stream " 8b/-> %ecx 0x00000000/r32" "F - test-convert-function-with-return-register-and-local-2/10") -12302 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-return-register-and-local-2/11") -12303 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-return-register-and-local-2/12") -12304 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-register-and-local-2/13") -12305 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-register-and-local-2/14") -12306 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-register-and-local-2/15") -12307 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-register-and-local-2/16") -12308 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-register-and-local-2/17") -12309 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-register-and-local-2/18") -12310 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-register-and-local-2/19") -12311 # . epilogue -12312 89/<- %esp 5/r32/ebp -12313 5d/pop-to-ebp -12314 c3/return -12315 -12316 test-convert-function-with-return-float-register-and-local: -12317 # . prologue -12318 55/push-ebp -12319 89/<- %ebp 4/r32/esp -12320 # setup -12321 (clear-stream _test-input-stream) -12322 (clear-stream $_test-input-buffered-file->buffer) -12323 (clear-stream _test-output-stream) -12324 (clear-stream $_test-output-buffered-file->buffer) -12325 # -12326 (write _test-input-stream "fn foo -> _/xmm1: float {\n") -12327 (write _test-input-stream " var y/eax: int <- copy 3\n") -12328 (write _test-input-stream " var g/xmm0: float <- convert y\n") -12329 (write _test-input-stream " var h/xmm1: float <- convert y\n") -12330 (write _test-input-stream " return g\n") -12331 (write _test-input-stream "}\n") -12332 # convert -12333 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -12334 (flush _test-output-buffered-file) -12335 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12341 # check output -12342 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-float-register-and-local/0") -12343 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-float-register-and-local/1") -12344 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-float-register-and-local/2") -12345 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-float-register-and-local/3") -12346 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-float-register-and-local/4") -12347 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-float-register-and-local/5") -12348 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-float-register-and-local/6") # var y -12349 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-float-register-and-local/7") -12350 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-function-with-return-float-register-and-local/8") # var g -12351 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 0/x32" "F - test-convert-function-with-return-float-register-and-local/9") -12352 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000000/x32" "F - test-convert-function-with-return-float-register-and-local/10") -12353 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-function-with-return-float-register-and-local/11") # var h -12354 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-function-with-return-float-register-and-local/12") -12355 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000001/x32" "F - test-convert-function-with-return-float-register-and-local/13") -12356 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> %xmm0 0x00000001/x32" "F - test-convert-function-with-return-float-register-and-local/14") # return g -12357 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-dereferenced/15") # reclaim h -12358 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 0/x32" "F - test-convert-floating-point-dereferenced/16") # reclaim g -12359 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-dereferenced/17") -12360 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-return-float-register-and-local/18") # reclaim y -12361 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-float-register-and-local/19") -12362 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-float-register-and-local/20") -12363 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-float-register-and-local/21") -12364 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-float-register-and-local/22") -12365 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-float-register-and-local/23") -12366 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-float-register-and-local/24") -12367 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-float-register-and-local/25") -12368 # . epilogue -12369 89/<- %esp 5/r32/ebp -12370 5d/pop-to-ebp -12371 c3/return -12372 -12373 test-convert-function-with-return-and-local-vars: -12374 # . prologue -12375 55/push-ebp -12376 89/<- %ebp 4/r32/esp -12377 # setup -12378 (clear-stream _test-input-stream) -12379 (clear-stream $_test-input-buffered-file->buffer) -12380 (clear-stream _test-output-stream) -12381 (clear-stream $_test-output-buffered-file->buffer) -12382 # -12383 (write _test-input-stream "fn foo -> _/eax: int {\n") -12384 (write _test-input-stream " {\n") -12385 (write _test-input-stream " var x: int\n") -12386 (write _test-input-stream " {\n") -12387 (write _test-input-stream " var y: int\n") -12388 (write _test-input-stream " return y\n") -12389 (write _test-input-stream " increment x\n") -12390 (write _test-input-stream " }\n") -12391 (write _test-input-stream " }\n") -12392 (write _test-input-stream " return 0\n") -12393 (write _test-input-stream "}\n") -12394 # convert -12395 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -12396 (flush _test-output-buffered-file) -12397 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12403 # check output -12404 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-and-local-vars/0") -12405 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-and-local-vars/1") -12406 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-and-local-vars/2") -12407 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-and-local-vars/3") -12408 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-and-local-vars/4") -12409 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-and-local-vars/5") -12410 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-and-local-vars/6") -12411 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-return-and-local-vars/7") -12412 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-return-and-local-vars/8") # var x -12413 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-and-local-vars/9") -12414 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-return-and-local-vars/10") -12415 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-return-and-local-vars/11") # var y -12416 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-with-return-and-local-vars/12") -12417 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return-and-local-vars/13") -12418 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return-and-local-vars/14") -12419 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-and-local-vars/15") -12420 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-and-local-vars/16") -12421 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-return-and-local-vars/17") -12422 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return-and-local-vars/18") -12423 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-and-local-vars/19") -12424 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-return-and-local-vars/20") -12425 (check-next-stream-line-equal _test-output-stream " c7 0/subop/copy %eax 0/imm32" "F - test-convert-function-with-return-and-local-vars/21") -12426 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-and-local-vars/21") -12427 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-and-local-vars/21") -12428 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-and-local-vars/22") -12429 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-and-local-vars/23") -12430 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-and-local-vars/24") -12431 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-and-local-vars/25") -12432 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-and-local-vars/26") -12433 # . epilogue -12434 89/<- %esp 5/r32/ebp -12435 5d/pop-to-ebp -12436 c3/return -12437 -12438 test-copy-object-with-no-inout: -12439 # . prologue -12440 55/push-ebp -12441 89/<- %ebp 4/r32/esp -12442 # setup -12443 (clear-stream _test-input-stream) -12444 (clear-stream $_test-input-buffered-file->buffer) -12445 (clear-stream _test-output-stream) -12446 (clear-stream $_test-output-buffered-file->buffer) -12447 (clear-stream _test-error-stream) -12448 (clear-stream $_test-error-buffered-file->buffer) -12449 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12450 68/push 0/imm32 -12451 68/push 0/imm32 -12452 89/<- %edx 4/r32/esp -12453 (tailor-exit-descriptor %edx 0x10) -12454 # -12455 (write _test-input-stream "fn foo {\n") -12456 (write _test-input-stream " copy-object\n") -12457 (write _test-input-stream "}\n") -12458 # convert -12459 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12460 # registers except esp clobbered at this point -12461 # restore ed -12462 89/<- %edx 4/r32/esp -12463 (flush _test-output-buffered-file) -12464 (flush _test-error-buffered-file) -12465 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12471 # check output -12472 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-no-inout: output should be empty") -12473 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must have two inouts" "F - test-copy-object-with-no-inout: error message") -12474 # check that stop(1) was called -12475 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-no-inout: exit status") -12476 # don't restore from ebp -12477 81 0/subop/add %esp 8/imm32 -12478 # . epilogue -12479 5d/pop-to-ebp -12480 c3/return -12481 -12482 test-copy-object-with-no-input: -12483 # . prologue -12484 55/push-ebp -12485 89/<- %ebp 4/r32/esp -12486 # setup -12487 (clear-stream _test-input-stream) -12488 (clear-stream $_test-input-buffered-file->buffer) -12489 (clear-stream _test-output-stream) -12490 (clear-stream $_test-output-buffered-file->buffer) -12491 (clear-stream _test-error-stream) -12492 (clear-stream $_test-error-buffered-file->buffer) -12493 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12494 68/push 0/imm32 -12495 68/push 0/imm32 -12496 89/<- %edx 4/r32/esp -12497 (tailor-exit-descriptor %edx 0x10) -12498 # -12499 (write _test-input-stream "fn foo {\n") -12500 (write _test-input-stream " var x: (addr int)\n") -12501 (write _test-input-stream " copy-object x\n") -12502 (write _test-input-stream "}\n") -12503 # convert -12504 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12505 # registers except esp clobbered at this point -12506 # restore ed -12507 89/<- %edx 4/r32/esp -12508 (flush _test-output-buffered-file) -12509 (flush _test-error-buffered-file) -12510 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12516 # check output -12517 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-no-input: output should be empty") -12518 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must have two inouts" "F - test-copy-object-with-no-input: error message") -12519 # check that stop(1) was called -12520 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-no-input: exit status") -12521 # don't restore from ebp -12522 81 0/subop/add %esp 8/imm32 -12523 # . epilogue -12524 5d/pop-to-ebp -12525 c3/return -12526 -12527 test-copy-object-with-too-many-inouts: -12528 # . prologue -12529 55/push-ebp -12530 89/<- %ebp 4/r32/esp -12531 # setup -12532 (clear-stream _test-input-stream) -12533 (clear-stream $_test-input-buffered-file->buffer) -12534 (clear-stream _test-output-stream) -12535 (clear-stream $_test-output-buffered-file->buffer) -12536 (clear-stream _test-error-stream) -12537 (clear-stream $_test-error-buffered-file->buffer) -12538 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12539 68/push 0/imm32 -12540 68/push 0/imm32 -12541 89/<- %edx 4/r32/esp -12542 (tailor-exit-descriptor %edx 0x10) -12543 # -12544 (write _test-input-stream "fn foo {\n") -12545 (write _test-input-stream " var x: (addr boolean)\n") -12546 (write _test-input-stream " copy-object x, x, x\n") -12547 (write _test-input-stream "}\n") -12548 # convert -12549 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12550 # registers except esp clobbered at this point -12551 # restore ed -12552 89/<- %edx 4/r32/esp -12553 (flush _test-output-buffered-file) -12554 (flush _test-error-buffered-file) -12555 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12561 # check output -12562 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-too-many-inouts: output should be empty") -12563 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must have two inouts" "F - test-copy-object-with-too-many-inouts: error message") -12564 # check that stop(1) was called -12565 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-too-many-inouts: exit status") -12566 # don't restore from ebp -12567 81 0/subop/add %esp 8/imm32 -12568 # . epilogue -12569 5d/pop-to-ebp -12570 c3/return -12571 -12572 test-copy-object-with-output: -12573 # . prologue -12574 55/push-ebp -12575 89/<- %ebp 4/r32/esp -12576 # setup -12577 (clear-stream _test-input-stream) -12578 (clear-stream $_test-input-buffered-file->buffer) -12579 (clear-stream _test-output-stream) -12580 (clear-stream $_test-output-buffered-file->buffer) -12581 (clear-stream _test-error-stream) -12582 (clear-stream $_test-error-buffered-file->buffer) -12583 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12584 68/push 0/imm32 -12585 68/push 0/imm32 -12586 89/<- %edx 4/r32/esp -12587 (tailor-exit-descriptor %edx 0x10) -12588 # -12589 (write _test-input-stream "fn foo {\n") -12590 (write _test-input-stream " var x/eax: (addr boolean) <- copy 0\n") -12591 (write _test-input-stream " var y/ecx: (addr boolean) <- copy 0\n") -12592 (write _test-input-stream " x <- copy-object x, y\n") -12593 (write _test-input-stream "}\n") -12594 # convert -12595 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12596 # registers except esp clobbered at this point -12597 # restore ed -12598 89/<- %edx 4/r32/esp -12599 (flush _test-output-buffered-file) -12600 (flush _test-error-buffered-file) -12601 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12607 # check output -12608 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-output: output should be empty") -12609 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must not have any outputs" "F - test-copy-object-with-output: error message") -12610 # check that stop(1) was called -12611 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-output: exit status") -12612 # don't restore from ebp -12613 81 0/subop/add %esp 8/imm32 -12614 # . epilogue -12615 5d/pop-to-ebp -12616 c3/return -12617 -12618 test-copy-object-deref-address: -12619 # . prologue -12620 55/push-ebp -12621 89/<- %ebp 4/r32/esp -12622 # setup -12623 (clear-stream _test-input-stream) -12624 (clear-stream $_test-input-buffered-file->buffer) -12625 (clear-stream _test-output-stream) -12626 (clear-stream $_test-output-buffered-file->buffer) -12627 # -12628 (write _test-input-stream "fn foo {\n") -12629 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") -12630 (write _test-input-stream " var y/ecx: (addr addr int) <- copy 0\n") -12631 (write _test-input-stream " copy-object *y, x\n") -12632 (write _test-input-stream "}\n") -12633 # convert -12634 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -12635 (flush _test-output-buffered-file) -12636 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12642 # not bothering checking output -12643 (check-next-stream-line-equal _test-error-stream "" "F - test-copy-object-deref-address: error message") -12644 # . epilogue -12645 5d/pop-to-ebp -12646 c3/return -12647 -12648 test-copy-object-non-addr: -12649 # . prologue -12650 55/push-ebp -12651 89/<- %ebp 4/r32/esp -12652 # setup -12653 (clear-stream _test-input-stream) -12654 (clear-stream $_test-input-buffered-file->buffer) -12655 (clear-stream _test-output-stream) -12656 (clear-stream $_test-output-buffered-file->buffer) -12657 (clear-stream _test-error-stream) -12658 (clear-stream $_test-error-buffered-file->buffer) -12659 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11609 (tailor-exit-descriptor %edx 0x10) +11610 # +11611 (write _test-input-stream "fn foo {\n") +11612 (write _test-input-stream " read-from-stream\n") +11613 (write _test-input-stream "}\n") +11614 # convert +11615 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11616 # registers except esp clobbered at this point +11617 # restore ed +11618 89/<- %edx 4/r32/esp +11619 (flush _test-output-buffered-file) +11620 (flush _test-error-buffered-file) +11621 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11627 # check output +11628 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-no-inouts: output should be empty") +11629 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: too few inouts (2 required)" "F - test-read-from-stream-with-no-inouts: error message") +11630 # check that stop(1) was called +11631 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-no-inouts: exit status") +11632 # don't restore from ebp +11633 81 0/subop/add %esp 8/imm32 +11634 # . epilogue +11635 5d/pop-to-ebp +11636 c3/return +11637 +11638 test-read-from-stream-with-too-few-inouts: +11639 # . prologue +11640 55/push-ebp +11641 89/<- %ebp 4/r32/esp +11642 # setup +11643 (clear-stream _test-input-stream) +11644 (clear-stream $_test-input-buffered-file->buffer) +11645 (clear-stream _test-output-stream) +11646 (clear-stream $_test-output-buffered-file->buffer) +11647 (clear-stream _test-error-stream) +11648 (clear-stream $_test-error-buffered-file->buffer) +11649 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11650 68/push 0/imm32 +11651 68/push 0/imm32 +11652 89/<- %edx 4/r32/esp +11653 (tailor-exit-descriptor %edx 0x10) +11654 # +11655 (write _test-input-stream "fn foo {\n") +11656 (write _test-input-stream " var a: (addr stream int)\n") +11657 (write _test-input-stream " read-from-stream a\n") +11658 (write _test-input-stream "}\n") +11659 # convert +11660 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11661 # registers except esp clobbered at this point +11662 # restore ed +11663 89/<- %edx 4/r32/esp +11664 (flush _test-output-buffered-file) +11665 (flush _test-error-buffered-file) +11666 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11672 # check output +11673 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-too-few-inouts: output should be empty") +11674 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: too few inouts (2 required)" "F - test-read-from-stream-with-too-few-inouts: error message") +11675 # check that stop(1) was called +11676 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-too-few-inouts: exit status") +11677 # don't restore from ebp +11678 81 0/subop/add %esp 8/imm32 +11679 # . epilogue +11680 5d/pop-to-ebp +11681 c3/return +11682 +11683 test-read-from-stream-with-too-many-inouts: +11684 # . prologue +11685 55/push-ebp +11686 89/<- %ebp 4/r32/esp +11687 # setup +11688 (clear-stream _test-input-stream) +11689 (clear-stream $_test-input-buffered-file->buffer) +11690 (clear-stream _test-output-stream) +11691 (clear-stream $_test-output-buffered-file->buffer) +11692 (clear-stream _test-error-stream) +11693 (clear-stream $_test-error-buffered-file->buffer) +11694 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11695 68/push 0/imm32 +11696 68/push 0/imm32 +11697 89/<- %edx 4/r32/esp +11698 (tailor-exit-descriptor %edx 0x10) +11699 # +11700 (write _test-input-stream "fn foo {\n") +11701 (write _test-input-stream " var a: (addr stream int)\n") +11702 (write _test-input-stream " var b: (addr int)\n") +11703 (write _test-input-stream " read-from-stream a, b, 0\n") +11704 (write _test-input-stream "}\n") +11705 # convert +11706 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11707 # registers except esp clobbered at this point +11708 # restore ed +11709 89/<- %edx 4/r32/esp +11710 (flush _test-output-buffered-file) +11711 (flush _test-error-buffered-file) +11712 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11718 # check output +11719 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-too-many-inouts: output should be empty") +11720 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: too many inouts (2 required)" "F - test-read-from-stream-with-too-many-inouts: error message") +11721 # check that stop(1) was called +11722 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-too-many-inouts: exit status") +11723 # don't restore from ebp +11724 81 0/subop/add %esp 8/imm32 +11725 # . epilogue +11726 5d/pop-to-ebp +11727 c3/return +11728 +11729 test-read-from-stream-with-output: +11730 # . prologue +11731 55/push-ebp +11732 89/<- %ebp 4/r32/esp +11733 # setup +11734 (clear-stream _test-input-stream) +11735 (clear-stream $_test-input-buffered-file->buffer) +11736 (clear-stream _test-output-stream) +11737 (clear-stream $_test-output-buffered-file->buffer) +11738 (clear-stream _test-error-stream) +11739 (clear-stream $_test-error-buffered-file->buffer) +11740 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11741 68/push 0/imm32 +11742 68/push 0/imm32 +11743 89/<- %edx 4/r32/esp +11744 (tailor-exit-descriptor %edx 0x10) +11745 # +11746 (write _test-input-stream "fn foo {\n") +11747 (write _test-input-stream " var a: (addr stream int)\n") +11748 (write _test-input-stream " var b/eax: (addr int) <- copy 0\n") +11749 (write _test-input-stream " b <- read-from-stream a, b\n") +11750 (write _test-input-stream "}\n") +11751 # convert +11752 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11753 # registers except esp clobbered at this point +11754 # restore ed +11755 89/<- %edx 4/r32/esp +11756 (flush _test-output-buffered-file) +11757 (flush _test-error-buffered-file) +11758 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11764 # check output +11765 (check-stream-equal _test-output-stream "" "F - test-read-from-stream-with-output: output should be empty") +11766 (check-next-stream-line-equal _test-error-stream "fn foo: stmt read-from-stream: unexpected output" "F - test-read-from-stream-with-output: error message") +11767 # check that stop(1) was called +11768 (check-ints-equal *(edx+4) 2 "F - test-read-from-stream-with-output: exit status") +11769 # don't restore from ebp +11770 81 0/subop/add %esp 8/imm32 +11771 # . epilogue +11772 5d/pop-to-ebp +11773 c3/return +11774 +11775 test-convert-write-to-stream: +11776 # . prologue +11777 55/push-ebp +11778 89/<- %ebp 4/r32/esp +11779 # setup +11780 (clear-stream _test-input-stream) +11781 (clear-stream $_test-input-buffered-file->buffer) +11782 (clear-stream _test-output-stream) +11783 (clear-stream $_test-output-buffered-file->buffer) +11784 # +11785 (write _test-input-stream "fn foo {\n") +11786 (write _test-input-stream " var s/esi: (addr stream int) <- copy 0\n") +11787 (write _test-input-stream " var o/ecx: (addr int) <- copy 0\n") +11788 (write _test-input-stream " write-to-stream s, o\n") +11789 (write _test-input-stream "}\n") +11790 # convert +11791 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +11792 # registers except esp clobbered at this point +11793 # restore ed +11794 89/<- %edx 4/r32/esp +11795 (flush _test-output-buffered-file) +11796 (flush _test-error-buffered-file) +11797 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11803 # check output +11804 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-write-to-stream/0") +11805 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-write-to-stream/1") +11806 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-write-to-stream/2") +11807 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-write-to-stream/3") +11808 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-write-to-stream/4") +11809 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-write-to-stream/5") +11810 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-write-to-stream/6") +11811 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-write-to-stream/7") +11812 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-write-to-stream/8") +11813 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-write-to-stream/9") +11814 (check-next-stream-line-equal _test-output-stream " (write-to-stream %esi %ecx 0x00000004)" "F - test-convert-write-to-stream/10") +11815 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-write-to-stream/11") +11816 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-write-to-stream/12") +11817 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-write-to-stream/13") +11818 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-write-to-stream/14") +11819 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-write-to-stream/15") +11820 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-write-to-stream/16") +11821 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-write-to-stream/17") +11822 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-write-to-stream/18") +11823 # . epilogue +11824 89/<- %esp 5/r32/ebp +11825 5d/pop-to-ebp +11826 c3/return +11827 +11828 test-convert-write-to-stream-with-correct-payload-size: +11829 # . prologue +11830 55/push-ebp +11831 89/<- %ebp 4/r32/esp +11832 # setup +11833 (clear-stream _test-input-stream) +11834 (clear-stream $_test-input-buffered-file->buffer) +11835 (clear-stream _test-output-stream) +11836 (clear-stream $_test-output-buffered-file->buffer) +11837 # +11838 (write _test-input-stream "fn foo {\n") +11839 (write _test-input-stream " var s/esi: (addr stream handle int) <- copy 0\n") +11840 (write _test-input-stream " var o/ecx: (addr handle int) <- copy 0\n") +11841 (write _test-input-stream " write-to-stream s, o\n") +11842 (write _test-input-stream "}\n") +11843 # convert +11844 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +11845 # registers except esp clobbered at this point +11846 # restore ed +11847 89/<- %edx 4/r32/esp +11848 (flush _test-output-buffered-file) +11849 (flush _test-error-buffered-file) +11850 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11856 # check output +11857 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-write-to-stream-with-correct-payload-size/0") +11858 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-write-to-stream-with-correct-payload-size/1") +11859 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-write-to-stream-with-correct-payload-size/2") +11860 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-write-to-stream-with-correct-payload-size/3") +11861 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-write-to-stream-with-correct-payload-size/4") +11862 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-write-to-stream-with-correct-payload-size/5") +11863 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %esi" "F - test-convert-write-to-stream-with-correct-payload-size/6") +11864 (check-next-stream-line-equal _test-output-stream " be/copy-to-esi 0/imm32" "F - test-convert-write-to-stream-with-correct-payload-size/7") +11865 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-write-to-stream-with-correct-payload-size/8") +11866 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 0/imm32" "F - test-convert-write-to-stream-with-correct-payload-size/9") +11867 (check-next-stream-line-equal _test-output-stream " (write-to-stream %esi %ecx 0x00000008)" "F - test-convert-write-to-stream-with-correct-payload-size/10") +11868 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-write-to-stream-with-correct-payload-size/11") +11869 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %esi" "F - test-convert-write-to-stream-with-correct-payload-size/12") +11870 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-write-to-stream-with-correct-payload-size/13") +11871 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-write-to-stream-with-correct-payload-size/14") +11872 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-write-to-stream-with-correct-payload-size/15") +11873 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-write-to-stream-with-correct-payload-size/16") +11874 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-write-to-stream-with-correct-payload-size/17") +11875 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-write-to-stream-with-correct-payload-size/18") +11876 # . epilogue +11877 89/<- %esp 5/r32/ebp +11878 5d/pop-to-ebp +11879 c3/return +11880 +11881 test-write-to-stream-with-non-stream-atom-base-type: +11882 # . prologue +11883 55/push-ebp +11884 89/<- %ebp 4/r32/esp +11885 # setup +11886 (clear-stream _test-input-stream) +11887 (clear-stream $_test-input-buffered-file->buffer) +11888 (clear-stream _test-output-stream) +11889 (clear-stream $_test-output-buffered-file->buffer) +11890 (clear-stream _test-error-stream) +11891 (clear-stream $_test-error-buffered-file->buffer) +11892 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11893 68/push 0/imm32 +11894 68/push 0/imm32 +11895 89/<- %edx 4/r32/esp +11896 (tailor-exit-descriptor %edx 0x10) +11897 # +11898 (write _test-input-stream "fn foo {\n") +11899 (write _test-input-stream " var a: int\n") +11900 (write _test-input-stream " write-to-stream a, 0\n") +11901 (write _test-input-stream "}\n") +11902 # convert +11903 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11904 # registers except esp clobbered at this point +11905 # restore ed +11906 89/<- %edx 4/r32/esp +11907 (flush _test-output-buffered-file) +11908 (flush _test-error-buffered-file) +11909 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11915 # check output +11916 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-non-stream-atom-base-type: output should be empty") +11917 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-non-stream-atom-base-type: error message") +11918 # check that stop(1) was called +11919 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-non-stream-atom-base-type: exit status") +11920 # don't restore from ebp +11921 81 0/subop/add %esp 8/imm32 +11922 # . epilogue +11923 5d/pop-to-ebp +11924 c3/return +11925 +11926 test-write-to-stream-with-non-stream-compound-base-type: +11927 # . prologue +11928 55/push-ebp +11929 89/<- %ebp 4/r32/esp +11930 # setup +11931 (clear-stream _test-input-stream) +11932 (clear-stream $_test-input-buffered-file->buffer) +11933 (clear-stream _test-output-stream) +11934 (clear-stream $_test-output-buffered-file->buffer) +11935 (clear-stream _test-error-stream) +11936 (clear-stream $_test-error-buffered-file->buffer) +11937 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11938 68/push 0/imm32 +11939 68/push 0/imm32 +11940 89/<- %edx 4/r32/esp +11941 (tailor-exit-descriptor %edx 0x10) +11942 # +11943 (write _test-input-stream "fn foo {\n") +11944 (write _test-input-stream " var a: (handle int)\n") +11945 (write _test-input-stream " write-to-stream a, 0\n") +11946 (write _test-input-stream "}\n") +11947 # convert +11948 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11949 # registers except esp clobbered at this point +11950 # restore ed +11951 89/<- %edx 4/r32/esp +11952 (flush _test-output-buffered-file) +11953 (flush _test-error-buffered-file) +11954 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +11960 # check output +11961 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-non-stream-compound-base-type: output should be empty") +11962 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-non-stream-compound-base-type: error message") +11963 # check that stop(1) was called +11964 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-non-stream-compound-base-type: exit status") +11965 # don't restore from ebp +11966 81 0/subop/add %esp 8/imm32 +11967 # . epilogue +11968 5d/pop-to-ebp +11969 c3/return +11970 +11971 test-write-to-stream-with-non-stream-compound-base-type-2: +11972 # . prologue +11973 55/push-ebp +11974 89/<- %ebp 4/r32/esp +11975 # setup +11976 (clear-stream _test-input-stream) +11977 (clear-stream $_test-input-buffered-file->buffer) +11978 (clear-stream _test-output-stream) +11979 (clear-stream $_test-output-buffered-file->buffer) +11980 (clear-stream _test-error-stream) +11981 (clear-stream $_test-error-buffered-file->buffer) +11982 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +11983 68/push 0/imm32 +11984 68/push 0/imm32 +11985 89/<- %edx 4/r32/esp +11986 (tailor-exit-descriptor %edx 0x10) +11987 # +11988 (write _test-input-stream "fn foo {\n") +11989 (write _test-input-stream " var a: (addr int)\n") +11990 (write _test-input-stream " write-to-stream a, 0\n") +11991 (write _test-input-stream "}\n") +11992 # convert +11993 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +11994 # registers except esp clobbered at this point +11995 # restore ed +11996 89/<- %edx 4/r32/esp +11997 (flush _test-output-buffered-file) +11998 (flush _test-error-buffered-file) +11999 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12005 # check output +12006 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-non-stream-compound-base-type-2: output should be empty") +12007 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-non-stream-compound-base-type-2: error message") +12008 # check that stop(1) was called +12009 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-non-stream-compound-base-type-2: exit status") +12010 # don't restore from ebp +12011 81 0/subop/add %esp 8/imm32 +12012 # . epilogue +12013 5d/pop-to-ebp +12014 c3/return +12015 +12016 test-write-to-stream-with-stream-atom-base-type: +12017 # . prologue +12018 55/push-ebp +12019 89/<- %ebp 4/r32/esp +12020 # setup +12021 (clear-stream _test-input-stream) +12022 (clear-stream $_test-input-buffered-file->buffer) +12023 (clear-stream _test-output-stream) +12024 (clear-stream $_test-output-buffered-file->buffer) +12025 (clear-stream _test-error-stream) +12026 (clear-stream $_test-error-buffered-file->buffer) +12027 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12028 68/push 0/imm32 +12029 68/push 0/imm32 +12030 89/<- %edx 4/r32/esp +12031 (tailor-exit-descriptor %edx 0x10) +12032 # +12033 (write _test-input-stream "fn foo {\n") +12034 (write _test-input-stream " var a: stream\n") +12035 (write _test-input-stream " write-to-stream a, 0\n") +12036 (write _test-input-stream "}\n") +12037 # convert +12038 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12039 # registers except esp clobbered at this point +12040 # restore ed +12041 89/<- %edx 4/r32/esp +12042 (flush _test-output-buffered-file) +12043 (flush _test-error-buffered-file) +12044 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12050 # check output +12051 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-stream-atom-base-type: output should be empty") +12052 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: var 'a' must be an addr to a stream" "F - test-write-to-stream-with-stream-atom-base-type: error message") +12053 # check that stop(1) was called +12054 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-stream-atom-base-type: exit status") +12055 # don't restore from ebp +12056 81 0/subop/add %esp 8/imm32 +12057 # . epilogue +12058 5d/pop-to-ebp +12059 c3/return +12060 +12061 test-write-to-stream-with-wrong-index-type: +12062 # . prologue +12063 55/push-ebp +12064 89/<- %ebp 4/r32/esp +12065 # setup +12066 (clear-stream _test-input-stream) +12067 (clear-stream $_test-input-buffered-file->buffer) +12068 (clear-stream _test-output-stream) +12069 (clear-stream $_test-output-buffered-file->buffer) +12070 (clear-stream _test-error-stream) +12071 (clear-stream $_test-error-buffered-file->buffer) +12072 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12073 68/push 0/imm32 +12074 68/push 0/imm32 +12075 89/<- %edx 4/r32/esp +12076 (tailor-exit-descriptor %edx 0x10) +12077 # +12078 (write _test-input-stream "fn foo {\n") +12079 (write _test-input-stream " var a/eax: (addr stream int) <- copy 0\n") +12080 (write _test-input-stream " var b: boolean\n") +12081 (write _test-input-stream " write-to-stream a, b\n") +12082 (write _test-input-stream "}\n") +12083 # convert +12084 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12085 # registers except esp clobbered at this point +12086 # restore ed +12087 89/<- %edx 4/r32/esp +12088 (flush _test-output-buffered-file) +12089 (flush _test-error-buffered-file) +12090 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12096 # check output +12097 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-wrong-index-type: output should be empty") +12098 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: target 'b' must be an addr" "F - test-write-to-stream-with-wrong-index-type: error message") +12099 # check that stop(1) was called +12100 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-wrong-index-type: exit status") +12101 # don't restore from ebp +12102 81 0/subop/add %esp 8/imm32 +12103 # . epilogue +12104 5d/pop-to-ebp +12105 c3/return +12106 +12107 test-write-to-stream-with-no-inouts: +12108 # . prologue +12109 55/push-ebp +12110 89/<- %ebp 4/r32/esp +12111 # setup +12112 (clear-stream _test-input-stream) +12113 (clear-stream $_test-input-buffered-file->buffer) +12114 (clear-stream _test-output-stream) +12115 (clear-stream $_test-output-buffered-file->buffer) +12116 (clear-stream _test-error-stream) +12117 (clear-stream $_test-error-buffered-file->buffer) +12118 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12119 68/push 0/imm32 +12120 68/push 0/imm32 +12121 89/<- %edx 4/r32/esp +12122 (tailor-exit-descriptor %edx 0x10) +12123 # +12124 (write _test-input-stream "fn foo {\n") +12125 (write _test-input-stream " write-to-stream\n") +12126 (write _test-input-stream "}\n") +12127 # convert +12128 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12129 # registers except esp clobbered at this point +12130 # restore ed +12131 89/<- %edx 4/r32/esp +12132 (flush _test-output-buffered-file) +12133 (flush _test-error-buffered-file) +12134 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12140 # check output +12141 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-no-inouts: output should be empty") +12142 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: too few inouts (2 required)" "F - test-write-to-stream-with-no-inouts: error message") +12143 # check that stop(1) was called +12144 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-no-inouts: exit status") +12145 # don't restore from ebp +12146 81 0/subop/add %esp 8/imm32 +12147 # . epilogue +12148 5d/pop-to-ebp +12149 c3/return +12150 +12151 test-write-to-stream-with-too-few-inouts: +12152 # . prologue +12153 55/push-ebp +12154 89/<- %ebp 4/r32/esp +12155 # setup +12156 (clear-stream _test-input-stream) +12157 (clear-stream $_test-input-buffered-file->buffer) +12158 (clear-stream _test-output-stream) +12159 (clear-stream $_test-output-buffered-file->buffer) +12160 (clear-stream _test-error-stream) +12161 (clear-stream $_test-error-buffered-file->buffer) +12162 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12163 68/push 0/imm32 +12164 68/push 0/imm32 +12165 89/<- %edx 4/r32/esp +12166 (tailor-exit-descriptor %edx 0x10) +12167 # +12168 (write _test-input-stream "fn foo {\n") +12169 (write _test-input-stream " var a: (addr stream int)\n") +12170 (write _test-input-stream " write-to-stream a\n") +12171 (write _test-input-stream "}\n") +12172 # convert +12173 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12174 # registers except esp clobbered at this point +12175 # restore ed +12176 89/<- %edx 4/r32/esp +12177 (flush _test-output-buffered-file) +12178 (flush _test-error-buffered-file) +12179 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12185 # check output +12186 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-too-few-inouts: output should be empty") +12187 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: too few inouts (2 required)" "F - test-write-to-stream-with-too-few-inouts: error message") +12188 # check that stop(1) was called +12189 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-too-few-inouts: exit status") +12190 # don't restore from ebp +12191 81 0/subop/add %esp 8/imm32 +12192 # . epilogue +12193 5d/pop-to-ebp +12194 c3/return +12195 +12196 test-write-to-stream-with-too-many-inouts: +12197 # . prologue +12198 55/push-ebp +12199 89/<- %ebp 4/r32/esp +12200 # setup +12201 (clear-stream _test-input-stream) +12202 (clear-stream $_test-input-buffered-file->buffer) +12203 (clear-stream _test-output-stream) +12204 (clear-stream $_test-output-buffered-file->buffer) +12205 (clear-stream _test-error-stream) +12206 (clear-stream $_test-error-buffered-file->buffer) +12207 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12208 68/push 0/imm32 +12209 68/push 0/imm32 +12210 89/<- %edx 4/r32/esp +12211 (tailor-exit-descriptor %edx 0x10) +12212 # +12213 (write _test-input-stream "fn foo {\n") +12214 (write _test-input-stream " var a: (addr stream int)\n") +12215 (write _test-input-stream " var b: (addr int)\n") +12216 (write _test-input-stream " write-to-stream a, b, 0\n") +12217 (write _test-input-stream "}\n") +12218 # convert +12219 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12220 # registers except esp clobbered at this point +12221 # restore ed +12222 89/<- %edx 4/r32/esp +12223 (flush _test-output-buffered-file) +12224 (flush _test-error-buffered-file) +12225 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12231 # check output +12232 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-too-many-inouts: output should be empty") +12233 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: too many inouts (2 required)" "F - test-write-to-stream-with-too-many-inouts: error message") +12234 # check that stop(1) was called +12235 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-too-many-inouts: exit status") +12236 # don't restore from ebp +12237 81 0/subop/add %esp 8/imm32 +12238 # . epilogue +12239 5d/pop-to-ebp +12240 c3/return +12241 +12242 test-write-to-stream-with-output: +12243 # . prologue +12244 55/push-ebp +12245 89/<- %ebp 4/r32/esp +12246 # setup +12247 (clear-stream _test-input-stream) +12248 (clear-stream $_test-input-buffered-file->buffer) +12249 (clear-stream _test-output-stream) +12250 (clear-stream $_test-output-buffered-file->buffer) +12251 (clear-stream _test-error-stream) +12252 (clear-stream $_test-error-buffered-file->buffer) +12253 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12254 68/push 0/imm32 +12255 68/push 0/imm32 +12256 89/<- %edx 4/r32/esp +12257 (tailor-exit-descriptor %edx 0x10) +12258 # +12259 (write _test-input-stream "fn foo {\n") +12260 (write _test-input-stream " var a: (addr stream int)\n") +12261 (write _test-input-stream " var b/eax: (addr int) <- copy 0\n") +12262 (write _test-input-stream " b <- write-to-stream a, b\n") +12263 (write _test-input-stream "}\n") +12264 # convert +12265 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12266 # registers except esp clobbered at this point +12267 # restore ed +12268 89/<- %edx 4/r32/esp +12269 (flush _test-output-buffered-file) +12270 (flush _test-error-buffered-file) +12271 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12277 # check output +12278 (check-stream-equal _test-output-stream "" "F - test-write-to-stream-with-output: output should be empty") +12279 (check-next-stream-line-equal _test-error-stream "fn foo: stmt write-to-stream: unexpected output" "F - test-write-to-stream-with-output: error message") +12280 # check that stop(1) was called +12281 (check-ints-equal *(edx+4) 2 "F - test-write-to-stream-with-output: exit status") +12282 # don't restore from ebp +12283 81 0/subop/add %esp 8/imm32 +12284 # . epilogue +12285 5d/pop-to-ebp +12286 c3/return +12287 +12288 test-length-with-non-array-atom-base-type: +12289 # . prologue +12290 55/push-ebp +12291 89/<- %ebp 4/r32/esp +12292 # setup +12293 (clear-stream _test-input-stream) +12294 (clear-stream $_test-input-buffered-file->buffer) +12295 (clear-stream _test-output-stream) +12296 (clear-stream $_test-output-buffered-file->buffer) +12297 (clear-stream _test-error-stream) +12298 (clear-stream $_test-error-buffered-file->buffer) +12299 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12300 68/push 0/imm32 +12301 68/push 0/imm32 +12302 89/<- %edx 4/r32/esp +12303 (tailor-exit-descriptor %edx 0x10) +12304 # +12305 (write _test-input-stream "fn foo {\n") +12306 (write _test-input-stream " var a: int\n") +12307 (write _test-input-stream " var c/ecx: int <- length a\n") +12308 (write _test-input-stream "}\n") +12309 # convert +12310 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12311 # registers except esp clobbered at this point +12312 # restore ed +12313 89/<- %edx 4/r32/esp +12314 (flush _test-output-buffered-file) +12315 (flush _test-error-buffered-file) +12316 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12322 # check output +12323 (check-stream-equal _test-output-stream "" "F - test-length-with-non-array-atom-base-type: output should be empty") +12324 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is not an array" "F - test-length-with-non-array-atom-base-type: error message") +12325 # check that stop(1) was called +12326 (check-ints-equal *(edx+4) 2 "F - test-length-with-non-array-atom-base-type: exit status") +12327 # don't restore from ebp +12328 81 0/subop/add %esp 8/imm32 +12329 # . epilogue +12330 5d/pop-to-ebp +12331 c3/return +12332 +12333 test-length-with-non-array-compound-base-type: +12334 # . prologue +12335 55/push-ebp +12336 89/<- %ebp 4/r32/esp +12337 # setup +12338 (clear-stream _test-input-stream) +12339 (clear-stream $_test-input-buffered-file->buffer) +12340 (clear-stream _test-output-stream) +12341 (clear-stream $_test-output-buffered-file->buffer) +12342 (clear-stream _test-error-stream) +12343 (clear-stream $_test-error-buffered-file->buffer) +12344 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12345 68/push 0/imm32 +12346 68/push 0/imm32 +12347 89/<- %edx 4/r32/esp +12348 (tailor-exit-descriptor %edx 0x10) +12349 # +12350 (write _test-input-stream "fn foo {\n") +12351 (write _test-input-stream " var a: (handle int)\n") +12352 (write _test-input-stream " var c/ecx: (addr int) <- length a, 0\n") +12353 (write _test-input-stream "}\n") +12354 # convert +12355 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12356 # registers except esp clobbered at this point +12357 # restore ed +12358 89/<- %edx 4/r32/esp +12359 (flush _test-output-buffered-file) +12360 (flush _test-error-buffered-file) +12361 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12367 # check output +12368 (check-stream-equal _test-output-stream "" "F - test-length-with-non-array-compound-base-type: output should be empty") +12369 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is not an array" "F - test-length-with-non-array-compound-base-type: error message") +12370 # check that stop(1) was called +12371 (check-ints-equal *(edx+4) 2 "F - test-length-with-non-array-compound-base-type: exit status") +12372 # don't restore from ebp +12373 81 0/subop/add %esp 8/imm32 +12374 # . epilogue +12375 5d/pop-to-ebp +12376 c3/return +12377 +12378 test-length-with-non-array-compound-base-type-2: +12379 # . prologue +12380 55/push-ebp +12381 89/<- %ebp 4/r32/esp +12382 # setup +12383 (clear-stream _test-input-stream) +12384 (clear-stream $_test-input-buffered-file->buffer) +12385 (clear-stream _test-output-stream) +12386 (clear-stream $_test-output-buffered-file->buffer) +12387 (clear-stream _test-error-stream) +12388 (clear-stream $_test-error-buffered-file->buffer) +12389 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12390 68/push 0/imm32 +12391 68/push 0/imm32 +12392 89/<- %edx 4/r32/esp +12393 (tailor-exit-descriptor %edx 0x10) +12394 # +12395 (write _test-input-stream "fn foo {\n") +12396 (write _test-input-stream " var a: (addr int)\n") +12397 (write _test-input-stream " var c/ecx: (addr int) <- length a, 0\n") +12398 (write _test-input-stream "}\n") +12399 # convert +12400 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12401 # registers except esp clobbered at this point +12402 # restore ed +12403 89/<- %edx 4/r32/esp +12404 (flush _test-output-buffered-file) +12405 (flush _test-error-buffered-file) +12406 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12412 # check output +12413 (check-stream-equal _test-output-stream "" "F - test-length-with-non-array-compound-base-type-2: output should be empty") +12414 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is not an array" "F - test-length-with-non-array-compound-base-type-2: error message") +12415 # check that stop(1) was called +12416 (check-ints-equal *(edx+4) 2 "F - test-length-with-non-array-compound-base-type-2: exit status") +12417 # don't restore from ebp +12418 81 0/subop/add %esp 8/imm32 +12419 # . epilogue +12420 5d/pop-to-ebp +12421 c3/return +12422 +12423 test-length-with-array-atom-base-type: +12424 # . prologue +12425 55/push-ebp +12426 89/<- %ebp 4/r32/esp +12427 # setup +12428 (clear-stream _test-input-stream) +12429 (clear-stream $_test-input-buffered-file->buffer) +12430 (clear-stream _test-output-stream) +12431 (clear-stream $_test-output-buffered-file->buffer) +12432 (clear-stream _test-error-stream) +12433 (clear-stream $_test-error-buffered-file->buffer) +12434 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12435 68/push 0/imm32 +12436 68/push 0/imm32 +12437 89/<- %edx 4/r32/esp +12438 (tailor-exit-descriptor %edx 0x10) +12439 # +12440 (write _test-input-stream "fn foo {\n") +12441 (write _test-input-stream " var a: array\n") +12442 (write _test-input-stream " var c/ecx: (addr int) <- length a\n") +12443 (write _test-input-stream "}\n") +12444 # convert +12445 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12446 # registers except esp clobbered at this point +12447 # restore ed +12448 89/<- %edx 4/r32/esp +12449 (flush _test-output-buffered-file) +12450 (flush _test-error-buffered-file) +12451 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12457 # check output +12458 (check-stream-equal _test-output-stream "" "F - test-length-with-array-atom-base-type: output should be empty") +12459 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: array 'a' must specify the type of its elements" "F - test-length-with-array-atom-base-type: error message") +12460 # check that stop(1) was called +12461 (check-ints-equal *(edx+4) 2 "F - test-length-with-array-atom-base-type: exit status") +12462 # don't restore from ebp +12463 81 0/subop/add %esp 8/imm32 +12464 # . epilogue +12465 5d/pop-to-ebp +12466 c3/return +12467 +12468 test-length-with-addr-base-on-stack: +12469 # . prologue +12470 55/push-ebp +12471 89/<- %ebp 4/r32/esp +12472 # setup +12473 (clear-stream _test-input-stream) +12474 (clear-stream $_test-input-buffered-file->buffer) +12475 (clear-stream _test-output-stream) +12476 (clear-stream $_test-output-buffered-file->buffer) +12477 (clear-stream _test-error-stream) +12478 (clear-stream $_test-error-buffered-file->buffer) +12479 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12480 68/push 0/imm32 +12481 68/push 0/imm32 +12482 89/<- %edx 4/r32/esp +12483 (tailor-exit-descriptor %edx 0x10) +12484 # +12485 (write _test-input-stream "fn foo {\n") +12486 (write _test-input-stream " var a: (addr array int)\n") +12487 (write _test-input-stream " var c/ecx: (addr int) <- length a\n") +12488 (write _test-input-stream "}\n") +12489 # convert +12490 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12491 # registers except esp clobbered at this point +12492 # restore ed +12493 89/<- %edx 4/r32/esp +12494 (flush _test-output-buffered-file) +12495 (flush _test-error-buffered-file) +12496 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12502 # check output +12503 (check-stream-equal _test-output-stream "" "F - test-length-with-addr-base-on-stack: output should be empty") +12504 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: var 'a' is an addr to an array, and so must live in a register" "F - test-length-with-addr-base-on-stack: error message") +12505 # check that stop(1) was called +12506 (check-ints-equal *(edx+4) 2 "F - test-length-with-addr-base-on-stack: exit status") +12507 # don't restore from ebp +12508 81 0/subop/add %esp 8/imm32 +12509 # . epilogue +12510 5d/pop-to-ebp +12511 c3/return +12512 +12513 test-length-with-wrong-output-type: +12514 # . prologue +12515 55/push-ebp +12516 89/<- %ebp 4/r32/esp +12517 # setup +12518 (clear-stream _test-input-stream) +12519 (clear-stream $_test-input-buffered-file->buffer) +12520 (clear-stream _test-output-stream) +12521 (clear-stream $_test-output-buffered-file->buffer) +12522 (clear-stream _test-error-stream) +12523 (clear-stream $_test-error-buffered-file->buffer) +12524 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12525 68/push 0/imm32 +12526 68/push 0/imm32 +12527 89/<- %edx 4/r32/esp +12528 (tailor-exit-descriptor %edx 0x10) +12529 # +12530 (write _test-input-stream "fn foo {\n") +12531 (write _test-input-stream " var a/ebx: (addr array boolean) <- copy 0\n") +12532 (write _test-input-stream " var o/edi: (addr int) <- length a\n") +12533 (write _test-input-stream "}\n") +12534 # convert +12535 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12536 # registers except esp clobbered at this point +12537 # restore ed +12538 89/<- %edx 4/r32/esp +12539 (flush _test-output-buffered-file) +12540 (flush _test-error-buffered-file) +12541 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12547 # check output +12548 (check-stream-equal _test-output-stream "" "F - test-length-with-wrong-output-type: output should be empty") +12549 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: output 'o' does not have the right type" "F - test-length-with-wrong-output-type: error message") +12550 # check that stop(1) was called +12551 (check-ints-equal *(edx+4) 2 "F - test-length-with-wrong-output-type: exit status") +12552 # don't restore from ebp +12553 81 0/subop/add %esp 8/imm32 +12554 # . epilogue +12555 5d/pop-to-ebp +12556 c3/return +12557 +12558 test-length-with-wrong-output-compound-type: +12559 # . prologue +12560 55/push-ebp +12561 89/<- %ebp 4/r32/esp +12562 # setup +12563 (clear-stream _test-input-stream) +12564 (clear-stream $_test-input-buffered-file->buffer) +12565 (clear-stream _test-output-stream) +12566 (clear-stream $_test-output-buffered-file->buffer) +12567 (clear-stream _test-error-stream) +12568 (clear-stream $_test-error-buffered-file->buffer) +12569 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12570 68/push 0/imm32 +12571 68/push 0/imm32 +12572 89/<- %edx 4/r32/esp +12573 (tailor-exit-descriptor %edx 0x10) +12574 # +12575 (write _test-input-stream "fn foo {\n") +12576 (write _test-input-stream " var a/ebx: (addr array handle boolean) <- copy 0\n") +12577 (write _test-input-stream " var o/edi: (addr handle int) <- length a\n") +12578 (write _test-input-stream "}\n") +12579 # convert +12580 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12581 # registers except esp clobbered at this point +12582 # restore ed +12583 89/<- %edx 4/r32/esp +12584 (flush _test-output-buffered-file) +12585 (flush _test-error-buffered-file) +12586 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12592 # check output +12593 (check-stream-equal _test-output-stream "" "F - test-length-with-wrong-output-compound-type: output should be empty") +12594 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: output 'o' does not have the right type" "F - test-length-with-wrong-output-compound-type: error message") +12595 # check that stop(1) was called +12596 (check-ints-equal *(edx+4) 2 "F - test-length-with-wrong-output-compound-type: exit status") +12597 # don't restore from ebp +12598 81 0/subop/add %esp 8/imm32 +12599 # . epilogue +12600 5d/pop-to-ebp +12601 c3/return +12602 +12603 test-length-with-no-inouts: +12604 # . prologue +12605 55/push-ebp +12606 89/<- %ebp 4/r32/esp +12607 # setup +12608 (clear-stream _test-input-stream) +12609 (clear-stream $_test-input-buffered-file->buffer) +12610 (clear-stream _test-output-stream) +12611 (clear-stream $_test-output-buffered-file->buffer) +12612 (clear-stream _test-error-stream) +12613 (clear-stream $_test-error-buffered-file->buffer) +12614 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12615 68/push 0/imm32 +12616 68/push 0/imm32 +12617 89/<- %edx 4/r32/esp +12618 (tailor-exit-descriptor %edx 0x10) +12619 # +12620 (write _test-input-stream "fn foo {\n") +12621 (write _test-input-stream " var c/ecx: int <- length\n") +12622 (write _test-input-stream "}\n") +12623 # convert +12624 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12625 # registers except esp clobbered at this point +12626 # restore ed +12627 89/<- %edx 4/r32/esp +12628 (flush _test-output-buffered-file) +12629 (flush _test-error-buffered-file) +12630 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12636 # check output +12637 (check-stream-equal _test-output-stream "" "F - test-length-with-no-inouts: output should be empty") +12638 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: too few inouts (1 required)" "F - test-length-with-no-inouts: error message") +12639 # check that stop(1) was called +12640 (check-ints-equal *(edx+4) 2 "F - test-length-with-no-inouts: exit status") +12641 # don't restore from ebp +12642 81 0/subop/add %esp 8/imm32 +12643 # . epilogue +12644 5d/pop-to-ebp +12645 c3/return +12646 +12647 test-length-with-too-many-inouts: +12648 # . prologue +12649 55/push-ebp +12650 89/<- %ebp 4/r32/esp +12651 # setup +12652 (clear-stream _test-input-stream) +12653 (clear-stream $_test-input-buffered-file->buffer) +12654 (clear-stream _test-output-stream) +12655 (clear-stream $_test-output-buffered-file->buffer) +12656 (clear-stream _test-error-stream) +12657 (clear-stream $_test-error-buffered-file->buffer) +12658 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12659 68/push 0/imm32 12660 68/push 0/imm32 -12661 68/push 0/imm32 -12662 89/<- %edx 4/r32/esp -12663 (tailor-exit-descriptor %edx 0x10) -12664 # -12665 (write _test-input-stream "fn foo {\n") -12666 (write _test-input-stream " var x: int\n") -12667 (write _test-input-stream " var y: int\n") -12668 (write _test-input-stream " copy-object y, x\n") -12669 (write _test-input-stream "}\n") -12670 # convert -12671 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12672 # registers except esp clobbered at this point -12673 # restore ed -12674 89/<- %edx 4/r32/esp -12675 (flush _test-output-buffered-file) -12676 (flush _test-error-buffered-file) -12677 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12683 # check output -12684 (check-stream-equal _test-output-stream "" "F - test-copy-object-non-addr: output should be empty") -12685 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-object: two inouts with identical addr types expected" "F - test-copy-object-non-addr: error message") -12686 # check that stop(1) was called -12687 (check-ints-equal *(edx+4) 2 "F - test-copy-object-non-addr: exit status") -12688 # don't restore from ebp -12689 81 0/subop/add %esp 8/imm32 -12690 # . epilogue -12691 5d/pop-to-ebp -12692 c3/return -12693 -12694 test-copy-object-non-equal: -12695 # . prologue -12696 55/push-ebp -12697 89/<- %ebp 4/r32/esp -12698 # setup -12699 (clear-stream _test-input-stream) -12700 (clear-stream $_test-input-buffered-file->buffer) -12701 (clear-stream _test-output-stream) -12702 (clear-stream $_test-output-buffered-file->buffer) -12703 (clear-stream _test-error-stream) -12704 (clear-stream $_test-error-buffered-file->buffer) -12705 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12706 68/push 0/imm32 -12707 68/push 0/imm32 -12708 89/<- %edx 4/r32/esp -12709 (tailor-exit-descriptor %edx 0x10) -12710 # -12711 (write _test-input-stream "fn foo {\n") -12712 (write _test-input-stream " var x: (addr int)\n") -12713 (write _test-input-stream " var y: (addr boolean)\n") -12714 (write _test-input-stream " copy-object y, x\n") -12715 (write _test-input-stream "}\n") -12716 # convert -12717 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12718 # registers except esp clobbered at this point -12719 # restore ed -12720 89/<- %edx 4/r32/esp -12721 (flush _test-output-buffered-file) -12722 (flush _test-error-buffered-file) -12723 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12729 # check output -12730 (check-stream-equal _test-output-stream "" "F - test-copy-object-non-equal: output should be empty") -12731 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-object: two inouts with identical addr types expected" "F - test-copy-object-non-equal: error message") -12732 # check that stop(1) was called -12733 (check-ints-equal *(edx+4) 2 "F - test-copy-object-non-equal: exit status") -12734 # don't restore from ebp -12735 81 0/subop/add %esp 8/imm32 -12736 # . epilogue -12737 5d/pop-to-ebp -12738 c3/return -12739 -12740 test-allocate-with-no-inout: -12741 # . prologue -12742 55/push-ebp -12743 89/<- %ebp 4/r32/esp -12744 # setup -12745 (clear-stream _test-input-stream) -12746 (clear-stream $_test-input-buffered-file->buffer) -12747 (clear-stream _test-output-stream) -12748 (clear-stream $_test-output-buffered-file->buffer) -12749 (clear-stream _test-error-stream) -12750 (clear-stream $_test-error-buffered-file->buffer) -12751 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12752 68/push 0/imm32 -12753 68/push 0/imm32 -12754 89/<- %edx 4/r32/esp -12755 (tailor-exit-descriptor %edx 0x10) -12756 # -12757 (write _test-input-stream "fn foo {\n") -12758 (write _test-input-stream " allocate\n") +12661 89/<- %edx 4/r32/esp +12662 (tailor-exit-descriptor %edx 0x10) +12663 # +12664 (write _test-input-stream "fn foo {\n") +12665 (write _test-input-stream " var a: (array int 3)\n") +12666 (write _test-input-stream " var c/ecx: int <- length a, 0, 0\n") +12667 (write _test-input-stream "}\n") +12668 # convert +12669 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12670 # registers except esp clobbered at this point +12671 # restore ed +12672 89/<- %edx 4/r32/esp +12673 (flush _test-output-buffered-file) +12674 (flush _test-error-buffered-file) +12675 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12681 # check output +12682 (check-stream-equal _test-output-stream "" "F - test-length-with-too-many-inouts: output should be empty") +12683 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: too many inouts (1 required)" "F - test-length-with-too-many-inouts: error message") +12684 # check that stop(1) was called +12685 (check-ints-equal *(edx+4) 2 "F - test-length-with-too-many-inouts: exit status") +12686 # don't restore from ebp +12687 81 0/subop/add %esp 8/imm32 +12688 # . epilogue +12689 5d/pop-to-ebp +12690 c3/return +12691 +12692 test-length-with-no-output: +12693 # . prologue +12694 55/push-ebp +12695 89/<- %ebp 4/r32/esp +12696 # setup +12697 (clear-stream _test-input-stream) +12698 (clear-stream $_test-input-buffered-file->buffer) +12699 (clear-stream _test-output-stream) +12700 (clear-stream $_test-output-buffered-file->buffer) +12701 (clear-stream _test-error-stream) +12702 (clear-stream $_test-error-buffered-file->buffer) +12703 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12704 68/push 0/imm32 +12705 68/push 0/imm32 +12706 89/<- %edx 4/r32/esp +12707 (tailor-exit-descriptor %edx 0x10) +12708 # +12709 (write _test-input-stream "fn foo {\n") +12710 (write _test-input-stream " var a: (array int 3)\n") +12711 (write _test-input-stream " length a\n") +12712 (write _test-input-stream "}\n") +12713 # convert +12714 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12715 # registers except esp clobbered at this point +12716 # restore ed +12717 89/<- %edx 4/r32/esp +12718 (flush _test-output-buffered-file) +12719 (flush _test-error-buffered-file) +12720 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12726 # check output +12727 (check-stream-equal _test-output-stream "" "F - test-length-with-no-output: output should be empty") +12728 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: must have an output" "F - test-length-with-no-output: error message") +12729 # check that stop(1) was called +12730 (check-ints-equal *(edx+4) 2 "F - test-length-with-no-output: exit status") +12731 # don't restore from ebp +12732 81 0/subop/add %esp 8/imm32 +12733 # . epilogue +12734 5d/pop-to-ebp +12735 c3/return +12736 +12737 test-length-with-too-many-outputs: +12738 # . prologue +12739 55/push-ebp +12740 89/<- %ebp 4/r32/esp +12741 # setup +12742 (clear-stream _test-input-stream) +12743 (clear-stream $_test-input-buffered-file->buffer) +12744 (clear-stream _test-output-stream) +12745 (clear-stream $_test-output-buffered-file->buffer) +12746 (clear-stream _test-error-stream) +12747 (clear-stream $_test-error-buffered-file->buffer) +12748 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +12749 68/push 0/imm32 +12750 68/push 0/imm32 +12751 89/<- %edx 4/r32/esp +12752 (tailor-exit-descriptor %edx 0x10) +12753 # +12754 (write _test-input-stream "fn foo {\n") +12755 (write _test-input-stream " var a: (array int 3)\n") +12756 (write _test-input-stream " var b/eax: int <- copy 0\n") +12757 (write _test-input-stream " var c/ecx: int <- copy 0\n") +12758 (write _test-input-stream " b, c <- length a\n") 12759 (write _test-input-stream "}\n") 12760 # convert -12761 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +12761 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) 12762 # registers except esp clobbered at this point 12763 # restore ed 12764 89/<- %edx 4/r32/esp 12765 (flush _test-output-buffered-file) -12766 (flush _test-error-buffered-file) +12766 (flush _test-error-buffered-file) 12767 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- 12773 # check output -12774 (check-stream-equal _test-output-stream "" "F - test-allocate-with-no-inout: output should be empty") -12775 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'allocate' must have a single inout" "F - test-allocate-with-no-inout: error message") +12774 (check-stream-equal _test-output-stream "" "F - test-length-with-too-many-outputs: output should be empty") +12775 (check-next-stream-line-equal _test-error-stream "fn foo: stmt length: too many outputs (1 required)" "F - test-length-with-too-many-outputs: error message") 12776 # check that stop(1) was called -12777 (check-ints-equal *(edx+4) 2 "F - test-allocate-with-no-inout: exit status") +12777 (check-ints-equal *(edx+4) 2 "F - test-length-with-too-many-outputs: exit status") 12778 # don't restore from ebp 12779 81 0/subop/add %esp 8/imm32 12780 # . epilogue 12781 5d/pop-to-ebp 12782 c3/return 12783 -12784 test-allocate-with-too-many-inouts: +12784 test-convert-function-with-return-register-and-local: 12785 # . prologue 12786 55/push-ebp 12787 89/<- %ebp 4/r32/esp @@ -11572,15309 +11572,15249 @@ if ('onhashchange' in window) { 12790 (clear-stream $_test-input-buffered-file->buffer) 12791 (clear-stream _test-output-stream) 12792 (clear-stream $_test-output-buffered-file->buffer) -12793 (clear-stream _test-error-stream) -12794 (clear-stream $_test-error-buffered-file->buffer) -12795 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12796 68/push 0/imm32 -12797 68/push 0/imm32 -12798 89/<- %edx 4/r32/esp -12799 (tailor-exit-descriptor %edx 0x10) -12800 # -12801 (write _test-input-stream "fn foo {\n") -12802 (write _test-input-stream " var x: (addr handle int)\n") -12803 (write _test-input-stream " allocate x, 0\n") -12804 (write _test-input-stream "}\n") -12805 # convert -12806 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12807 # registers except esp clobbered at this point -12808 # restore ed -12809 89/<- %edx 4/r32/esp -12810 (flush _test-output-buffered-file) -12811 (flush _test-error-buffered-file) -12812 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12818 # check output -12819 (check-stream-equal _test-output-stream "" "F - test-allocate-with-too-many-inouts: output should be empty") -12820 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'allocate' must have a single inout" "F - test-allocate-with-too-many-inouts: error message") -12821 # check that stop(1) was called -12822 (check-ints-equal *(edx+4) 2 "F - test-allocate-with-too-many-inouts: exit status") -12823 # don't restore from ebp -12824 81 0/subop/add %esp 8/imm32 -12825 # . epilogue -12826 5d/pop-to-ebp -12827 c3/return -12828 -12829 test-allocate-with-output: -12830 # . prologue -12831 55/push-ebp -12832 89/<- %ebp 4/r32/esp -12833 # setup -12834 (clear-stream _test-input-stream) -12835 (clear-stream $_test-input-buffered-file->buffer) -12836 (clear-stream _test-output-stream) -12837 (clear-stream $_test-output-buffered-file->buffer) -12838 (clear-stream _test-error-stream) -12839 (clear-stream $_test-error-buffered-file->buffer) -12840 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12841 68/push 0/imm32 -12842 68/push 0/imm32 -12843 89/<- %edx 4/r32/esp -12844 (tailor-exit-descriptor %edx 0x10) -12845 # -12846 (write _test-input-stream "fn foo {\n") -12847 (write _test-input-stream " var x/eax: boolean <- copy 0\n") -12848 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") -12849 (write _test-input-stream " x <- allocate y\n") -12850 (write _test-input-stream "}\n") -12851 # convert -12852 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12853 # registers except esp clobbered at this point -12854 # restore ed -12855 89/<- %edx 4/r32/esp -12856 (flush _test-output-buffered-file) -12857 (flush _test-error-buffered-file) -12858 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12864 # check output -12865 (check-stream-equal _test-output-stream "" "F - test-allocate-with-output: output should be empty") -12866 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'allocate' must not have any outputs" "F - test-allocate-with-output: error message") -12867 # check that stop(1) was called -12868 (check-ints-equal *(edx+4) 2 "F - test-allocate-with-output: exit status") -12869 # don't restore from ebp -12870 81 0/subop/add %esp 8/imm32 -12871 # . epilogue -12872 5d/pop-to-ebp -12873 c3/return -12874 -12875 test-allocate-non-addr: -12876 # . prologue -12877 55/push-ebp -12878 89/<- %ebp 4/r32/esp -12879 # setup -12880 (clear-stream _test-input-stream) -12881 (clear-stream $_test-input-buffered-file->buffer) -12882 (clear-stream _test-output-stream) -12883 (clear-stream $_test-output-buffered-file->buffer) -12884 (clear-stream _test-error-stream) -12885 (clear-stream $_test-error-buffered-file->buffer) -12886 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12887 68/push 0/imm32 -12888 68/push 0/imm32 -12889 89/<- %edx 4/r32/esp -12890 (tailor-exit-descriptor %edx 0x10) -12891 # -12892 (write _test-input-stream "fn foo {\n") -12893 (write _test-input-stream " var y: (handle int)\n") -12894 (write _test-input-stream " allocate y\n") -12895 (write _test-input-stream "}\n") -12896 # convert -12897 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12898 # registers except esp clobbered at this point -12899 # restore ed -12900 89/<- %edx 4/r32/esp -12901 (flush _test-output-buffered-file) -12902 (flush _test-error-buffered-file) -12903 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12793 # +12794 (write _test-input-stream "fn foo -> _/eax: int {\n") +12795 (write _test-input-stream " var y/eax: int <- copy 3\n") +12796 (write _test-input-stream " var z/ecx: int <- copy 4\n") +12797 (write _test-input-stream " return y\n") +12798 (write _test-input-stream "}\n") +12799 # convert +12800 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +12801 (flush _test-output-buffered-file) +12802 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12808 # check output +12809 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-register-and-local/0") +12810 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-register-and-local/1") +12811 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-register-and-local/2") +12812 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-register-and-local/3") +12813 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-register-and-local/4") +12814 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-register-and-local/5") +12815 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-register-and-local/6") +12816 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-register-and-local/7") +12817 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-return-register-and-local/8") +12818 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-convert-function-with-return-register-and-local/9") +12819 (check-next-stream-line-equal _test-output-stream " 8b/-> %eax 0x00000000/r32" "F - test-convert-function-with-return-register-and-local/10") +12820 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-return-register-and-local/11") +12821 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-return-register-and-local/12") +12822 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-register-and-local/13") +12823 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-register-and-local/14") +12824 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-register-and-local/15") +12825 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-register-and-local/16") +12826 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-register-and-local/17") +12827 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-register-and-local/18") +12828 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-register-and-local/19") +12829 # . epilogue +12830 89/<- %esp 5/r32/ebp +12831 5d/pop-to-ebp +12832 c3/return +12833 +12834 test-convert-function-with-return-register-and-local-2: +12835 # . prologue +12836 55/push-ebp +12837 89/<- %ebp 4/r32/esp +12838 # setup +12839 (clear-stream _test-input-stream) +12840 (clear-stream $_test-input-buffered-file->buffer) +12841 (clear-stream _test-output-stream) +12842 (clear-stream $_test-output-buffered-file->buffer) +12843 # +12844 (write _test-input-stream "fn foo -> _/eax: int {\n") +12845 (write _test-input-stream " var y/eax: int <- copy 3\n") +12846 (write _test-input-stream " var z/ecx: int <- copy 4\n") +12847 (write _test-input-stream " return z\n") +12848 (write _test-input-stream "}\n") +12849 # convert +12850 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +12851 (flush _test-output-buffered-file) +12852 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12858 # check output +12859 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-register-and-local-2/0") +12860 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-register-and-local-2/1") +12861 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-register-and-local-2/2") +12862 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-register-and-local-2/3") +12863 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-register-and-local-2/4") +12864 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-register-and-local-2/5") +12865 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-register-and-local-2/6") +12866 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-register-and-local-2/7") +12867 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %ecx" "F - test-convert-function-with-return-register-and-local-2/8") +12868 (check-next-stream-line-equal _test-output-stream " b9/copy-to-ecx 4/imm32" "F - test-convert-function-with-return-register-and-local-2/9") +12869 (check-next-stream-line-equal _test-output-stream " 8b/-> %ecx 0x00000000/r32" "F - test-convert-function-with-return-register-and-local-2/10") +12870 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %ecx" "F - test-convert-function-with-return-register-and-local-2/11") +12871 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-function-with-return-register-and-local-2/12") +12872 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-register-and-local-2/13") +12873 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-register-and-local-2/14") +12874 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-register-and-local-2/15") +12875 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-register-and-local-2/16") +12876 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-register-and-local-2/17") +12877 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-register-and-local-2/18") +12878 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-register-and-local-2/19") +12879 # . epilogue +12880 89/<- %esp 5/r32/ebp +12881 5d/pop-to-ebp +12882 c3/return +12883 +12884 test-convert-function-with-return-float-register-and-local: +12885 # . prologue +12886 55/push-ebp +12887 89/<- %ebp 4/r32/esp +12888 # setup +12889 (clear-stream _test-input-stream) +12890 (clear-stream $_test-input-buffered-file->buffer) +12891 (clear-stream _test-output-stream) +12892 (clear-stream $_test-output-buffered-file->buffer) +12893 # +12894 (write _test-input-stream "fn foo -> _/xmm1: float {\n") +12895 (write _test-input-stream " var y/eax: int <- copy 3\n") +12896 (write _test-input-stream " var g/xmm0: float <- convert y\n") +12897 (write _test-input-stream " var h/xmm1: float <- convert y\n") +12898 (write _test-input-stream " return g\n") +12899 (write _test-input-stream "}\n") +12900 # convert +12901 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +12902 (flush _test-output-buffered-file) +12903 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 12909 # check output -12910 (check-stream-equal _test-output-stream "" "F - test-allocate-non-addr: output must be empty") -12911 (check-next-stream-line-equal _test-error-stream "fn foo: stmt allocate: inout 'y' must have type (addr handle ...)" "F - test-allocate-non-addr: error message") -12912 # check that stop(1) was called -12913 (check-ints-equal *(edx+4) 2 "F - test-allocate-non-addr: exit status") -12914 # don't restore from ebp -12915 81 0/subop/add %esp 8/imm32 -12916 # . epilogue -12917 5d/pop-to-ebp -12918 c3/return -12919 -12920 test-allocate-non-addr-handle: -12921 # . prologue -12922 55/push-ebp -12923 89/<- %ebp 4/r32/esp -12924 # setup -12925 (clear-stream _test-input-stream) -12926 (clear-stream $_test-input-buffered-file->buffer) -12927 (clear-stream _test-output-stream) -12928 (clear-stream $_test-output-buffered-file->buffer) -12929 (clear-stream _test-error-stream) -12930 (clear-stream $_test-error-buffered-file->buffer) -12931 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -12932 68/push 0/imm32 -12933 68/push 0/imm32 -12934 89/<- %edx 4/r32/esp -12935 (tailor-exit-descriptor %edx 0x10) -12936 # -12937 (write _test-input-stream "fn foo {\n") -12938 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") -12939 (write _test-input-stream " allocate y\n") -12940 (write _test-input-stream "}\n") -12941 # convert -12942 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -12943 # registers except esp clobbered at this point -12944 # restore ed -12945 89/<- %edx 4/r32/esp -12946 (flush _test-output-buffered-file) -12947 (flush _test-error-buffered-file) -12948 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12954 # check output -12955 (check-stream-equal _test-output-stream "" "F - test-allocate-non-addr-handle: output should be empty") -12956 (check-next-stream-line-equal _test-error-stream "fn foo: stmt allocate: inout 'y' must have type (addr handle ...)" "F - test-allocate-non-addr-handle: error message") -12957 # check that stop(1) was called -12958 (check-ints-equal *(edx+4) 2 "F - test-allocate-non-addr-handle: exit status") -12959 # don't restore from ebp -12960 81 0/subop/add %esp 8/imm32 -12961 # . epilogue -12962 5d/pop-to-ebp -12963 c3/return -12964 -12965 test-allocate-deref-address: -12966 # . prologue -12967 55/push-ebp -12968 89/<- %ebp 4/r32/esp -12969 # setup -12970 (clear-stream _test-input-stream) -12971 (clear-stream $_test-input-buffered-file->buffer) -12972 (clear-stream _test-output-stream) -12973 (clear-stream $_test-output-buffered-file->buffer) -12974 # -12975 (write _test-input-stream "fn foo {\n") -12976 (write _test-input-stream " var y/ecx: (addr addr handle int) <- copy 0\n") -12977 (write _test-input-stream " allocate *y\n") -12978 (write _test-input-stream "}\n") -12979 # convert -12980 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -12981 (flush _test-output-buffered-file) -12982 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -12988 # not bothering checking output -12989 (check-next-stream-line-equal _test-error-stream "" "F - test-allocate-deref-address: error message") -12990 # . epilogue -12991 5d/pop-to-ebp -12992 c3/return -12993 -12994 test-populate-with-no-inout: -12995 # . prologue -12996 55/push-ebp -12997 89/<- %ebp 4/r32/esp -12998 # setup -12999 (clear-stream _test-input-stream) -13000 (clear-stream $_test-input-buffered-file->buffer) -13001 (clear-stream _test-output-stream) -13002 (clear-stream $_test-output-buffered-file->buffer) -13003 (clear-stream _test-error-stream) -13004 (clear-stream $_test-error-buffered-file->buffer) -13005 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13006 68/push 0/imm32 -13007 68/push 0/imm32 -13008 89/<- %edx 4/r32/esp -13009 (tailor-exit-descriptor %edx 0x10) -13010 # -13011 (write _test-input-stream "fn foo {\n") -13012 (write _test-input-stream " populate\n") -13013 (write _test-input-stream "}\n") -13014 # convert -13015 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13016 # registers except esp clobbered at this point -13017 # restore ed -13018 89/<- %edx 4/r32/esp -13019 (flush _test-output-buffered-file) -13020 (flush _test-error-buffered-file) -13021 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13027 # check output -13028 (check-stream-equal _test-output-stream "" "F - test-populate-with-no-inout: output should be empty") -13029 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate' must have two inouts" "F - test-populate-with-no-inout: error message") -13030 # check that stop(1) was called -13031 (check-ints-equal *(edx+4) 2 "F - test-populate-with-no-inout: exit status") -13032 # don't restore from ebp -13033 81 0/subop/add %esp 8/imm32 -13034 # . epilogue -13035 5d/pop-to-ebp -13036 c3/return -13037 -13038 test-populate-with-too-many-inouts: -13039 # . prologue -13040 55/push-ebp -13041 89/<- %ebp 4/r32/esp -13042 # setup -13043 (clear-stream _test-input-stream) -13044 (clear-stream $_test-input-buffered-file->buffer) -13045 (clear-stream _test-output-stream) -13046 (clear-stream $_test-output-buffered-file->buffer) -13047 (clear-stream _test-error-stream) -13048 (clear-stream $_test-error-buffered-file->buffer) -13049 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13050 68/push 0/imm32 -13051 68/push 0/imm32 -13052 89/<- %edx 4/r32/esp -13053 (tailor-exit-descriptor %edx 0x10) -13054 # -13055 (write _test-input-stream "fn foo {\n") -13056 (write _test-input-stream " var x: (addr handle int)\n") -13057 (write _test-input-stream " populate x, 3, 0\n") -13058 (write _test-input-stream "}\n") -13059 # convert -13060 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13061 # registers except esp clobbered at this point -13062 # restore ed -13063 89/<- %edx 4/r32/esp -13064 (flush _test-output-buffered-file) -13065 (flush _test-error-buffered-file) -13066 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13072 # check output -13073 (check-stream-equal _test-output-stream "" "F - test-populate-with-too-many-inouts: output should be empty") -13074 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate' must have two inouts" "F - test-populate-with-too-many-inouts: error message") -13075 # check that stop(1) was called -13076 (check-ints-equal *(edx+4) 2 "F - test-populate-with-too-many-inouts: exit status") -13077 # don't restore from ebp -13078 81 0/subop/add %esp 8/imm32 -13079 # . epilogue -13080 5d/pop-to-ebp -13081 c3/return -13082 -13083 test-populate-with-output: -13084 # . prologue -13085 55/push-ebp -13086 89/<- %ebp 4/r32/esp -13087 # setup -13088 (clear-stream _test-input-stream) -13089 (clear-stream $_test-input-buffered-file->buffer) -13090 (clear-stream _test-output-stream) -13091 (clear-stream $_test-output-buffered-file->buffer) -13092 (clear-stream _test-error-stream) -13093 (clear-stream $_test-error-buffered-file->buffer) -13094 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13095 68/push 0/imm32 -13096 68/push 0/imm32 -13097 89/<- %edx 4/r32/esp -13098 (tailor-exit-descriptor %edx 0x10) -13099 # -13100 (write _test-input-stream "fn foo {\n") -13101 (write _test-input-stream " var x/eax: boolean <- copy 0\n") -13102 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") -13103 (write _test-input-stream " x <- populate y\n") -13104 (write _test-input-stream "}\n") -13105 # convert -13106 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13107 # registers except esp clobbered at this point -13108 # restore ed +12910 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-float-register-and-local/0") +12911 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-float-register-and-local/1") +12912 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-float-register-and-local/2") +12913 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-float-register-and-local/3") +12914 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-float-register-and-local/4") +12915 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-float-register-and-local/5") +12916 (check-next-stream-line-equal _test-output-stream " ff 6/subop/push %eax" "F - test-convert-function-with-return-float-register-and-local/6") # var y +12917 (check-next-stream-line-equal _test-output-stream " b8/copy-to-eax 3/imm32" "F - test-convert-function-with-return-float-register-and-local/7") +12918 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-function-with-return-float-register-and-local/8") # var g +12919 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 0/x32" "F - test-convert-function-with-return-float-register-and-local/9") +12920 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000000/x32" "F - test-convert-function-with-return-float-register-and-local/10") +12921 (check-next-stream-line-equal _test-output-stream " 81 5/subop/subtract %esp 4/imm32" "F - test-convert-function-with-return-float-register-and-local/11") # var h +12922 (check-next-stream-line-equal _test-output-stream " f3 0f 11/<- *esp 1/x32" "F - test-convert-function-with-return-float-register-and-local/12") +12923 (check-next-stream-line-equal _test-output-stream " f3 0f 2a/convert-to-float %eax 0x00000001/x32" "F - test-convert-function-with-return-float-register-and-local/13") +12924 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> %xmm0 0x00000001/x32" "F - test-convert-function-with-return-float-register-and-local/14") # return g +12925 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-dereferenced/15") # reclaim h +12926 (check-next-stream-line-equal _test-output-stream " f3 0f 10/-> *esp 0/x32" "F - test-convert-floating-point-dereferenced/16") # reclaim g +12927 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 4/imm32" "F - test-convert-floating-point-dereferenced/17") +12928 (check-next-stream-line-equal _test-output-stream " 8f 0/subop/pop %eax" "F - test-convert-function-with-return-float-register-and-local/18") # reclaim y +12929 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-float-register-and-local/19") +12930 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-float-register-and-local/20") +12931 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-float-register-and-local/21") +12932 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-float-register-and-local/22") +12933 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-float-register-and-local/23") +12934 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-float-register-and-local/24") +12935 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-float-register-and-local/25") +12936 # . epilogue +12937 89/<- %esp 5/r32/ebp +12938 5d/pop-to-ebp +12939 c3/return +12940 +12941 test-convert-function-with-return-and-local-vars: +12942 # . prologue +12943 55/push-ebp +12944 89/<- %ebp 4/r32/esp +12945 # setup +12946 (clear-stream _test-input-stream) +12947 (clear-stream $_test-input-buffered-file->buffer) +12948 (clear-stream _test-output-stream) +12949 (clear-stream $_test-output-buffered-file->buffer) +12950 # +12951 (write _test-input-stream "fn foo -> _/eax: int {\n") +12952 (write _test-input-stream " {\n") +12953 (write _test-input-stream " var x: int\n") +12954 (write _test-input-stream " {\n") +12955 (write _test-input-stream " var y: int\n") +12956 (write _test-input-stream " return y\n") +12957 (write _test-input-stream " increment x\n") +12958 (write _test-input-stream " }\n") +12959 (write _test-input-stream " }\n") +12960 (write _test-input-stream " return 0\n") +12961 (write _test-input-stream "}\n") +12962 # convert +12963 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +12964 (flush _test-output-buffered-file) +12965 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +12971 # check output +12972 (check-next-stream-line-equal _test-output-stream "foo:" "F - test-convert-function-with-return-and-local-vars/0") +12973 (check-next-stream-line-equal _test-output-stream " # . prologue" "F - test-convert-function-with-return-and-local-vars/1") +12974 (check-next-stream-line-equal _test-output-stream " 55/push-ebp" "F - test-convert-function-with-return-and-local-vars/2") +12975 (check-next-stream-line-equal _test-output-stream " 89/<- %ebp 4/r32/esp" "F - test-convert-function-with-return-and-local-vars/3") +12976 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-and-local-vars/4") +12977 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:loop:" "F - test-convert-function-with-return-and-local-vars/5") +12978 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-and-local-vars/6") +12979 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:loop:" "F - test-convert-function-with-return-and-local-vars/7") +12980 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-return-and-local-vars/8") # var x +12981 (check-next-stream-line-equal _test-output-stream " {" "F - test-convert-function-with-return-and-local-vars/9") +12982 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:loop:" "F - test-convert-function-with-return-and-local-vars/10") +12983 (check-next-stream-line-equal _test-output-stream " 68/push 0/imm32" "F - test-convert-function-with-return-and-local-vars/11") # var y +12984 (check-next-stream-line-equal _test-output-stream " 8b/-> *(ebp+0xfffffff8) 0x00000000/r32" "F - test-convert-function-with-return-and-local-vars/12") +12985 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return-and-local-vars/13") +12986 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return-and-local-vars/14") +12987 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-and-local-vars/15") +12988 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-and-local-vars/16") +12989 (check-next-stream-line-equal _test-output-stream "$foo:0x00000003:break:" "F - test-convert-function-with-return-and-local-vars/17") +12990 (check-next-stream-line-equal _test-output-stream " 81 0/subop/add %esp 0x00000004/imm32" "F - test-convert-function-with-return-and-local-vars/18") +12991 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-and-local-vars/19") +12992 (check-next-stream-line-equal _test-output-stream "$foo:0x00000002:break:" "F - test-convert-function-with-return-and-local-vars/20") +12993 (check-next-stream-line-equal _test-output-stream " c7 0/subop/copy %eax 0/imm32" "F - test-convert-function-with-return-and-local-vars/21") +12994 (check-next-stream-line-equal _test-output-stream " e9/jump $foo:0x00000001:break/disp32" "F - test-convert-function-with-return-and-local-vars/21") +12995 (check-next-stream-line-equal _test-output-stream " }" "F - test-convert-function-with-return-and-local-vars/21") +12996 (check-next-stream-line-equal _test-output-stream "$foo:0x00000001:break:" "F - test-convert-function-with-return-and-local-vars/22") +12997 (check-next-stream-line-equal _test-output-stream " # . epilogue" "F - test-convert-function-with-return-and-local-vars/23") +12998 (check-next-stream-line-equal _test-output-stream " 89/<- %esp 5/r32/ebp" "F - test-convert-function-with-return-and-local-vars/24") +12999 (check-next-stream-line-equal _test-output-stream " 5d/pop-to-ebp" "F - test-convert-function-with-return-and-local-vars/25") +13000 (check-next-stream-line-equal _test-output-stream " c3/return" "F - test-convert-function-with-return-and-local-vars/26") +13001 # . epilogue +13002 89/<- %esp 5/r32/ebp +13003 5d/pop-to-ebp +13004 c3/return +13005 +13006 test-copy-object-with-no-inout: +13007 # . prologue +13008 55/push-ebp +13009 89/<- %ebp 4/r32/esp +13010 # setup +13011 (clear-stream _test-input-stream) +13012 (clear-stream $_test-input-buffered-file->buffer) +13013 (clear-stream _test-output-stream) +13014 (clear-stream $_test-output-buffered-file->buffer) +13015 (clear-stream _test-error-stream) +13016 (clear-stream $_test-error-buffered-file->buffer) +13017 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13018 68/push 0/imm32 +13019 68/push 0/imm32 +13020 89/<- %edx 4/r32/esp +13021 (tailor-exit-descriptor %edx 0x10) +13022 # +13023 (write _test-input-stream "fn foo {\n") +13024 (write _test-input-stream " copy-object\n") +13025 (write _test-input-stream "}\n") +13026 # convert +13027 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13028 # registers except esp clobbered at this point +13029 # restore ed +13030 89/<- %edx 4/r32/esp +13031 (flush _test-output-buffered-file) +13032 (flush _test-error-buffered-file) +13033 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13039 # check output +13040 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-no-inout: output should be empty") +13041 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must have two inouts" "F - test-copy-object-with-no-inout: error message") +13042 # check that stop(1) was called +13043 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-no-inout: exit status") +13044 # don't restore from ebp +13045 81 0/subop/add %esp 8/imm32 +13046 # . epilogue +13047 5d/pop-to-ebp +13048 c3/return +13049 +13050 test-copy-object-with-no-input: +13051 # . prologue +13052 55/push-ebp +13053 89/<- %ebp 4/r32/esp +13054 # setup +13055 (clear-stream _test-input-stream) +13056 (clear-stream $_test-input-buffered-file->buffer) +13057 (clear-stream _test-output-stream) +13058 (clear-stream $_test-output-buffered-file->buffer) +13059 (clear-stream _test-error-stream) +13060 (clear-stream $_test-error-buffered-file->buffer) +13061 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13062 68/push 0/imm32 +13063 68/push 0/imm32 +13064 89/<- %edx 4/r32/esp +13065 (tailor-exit-descriptor %edx 0x10) +13066 # +13067 (write _test-input-stream "fn foo {\n") +13068 (write _test-input-stream " var x: (addr int)\n") +13069 (write _test-input-stream " copy-object x\n") +13070 (write _test-input-stream "}\n") +13071 # convert +13072 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13073 # registers except esp clobbered at this point +13074 # restore ed +13075 89/<- %edx 4/r32/esp +13076 (flush _test-output-buffered-file) +13077 (flush _test-error-buffered-file) +13078 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13084 # check output +13085 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-no-input: output should be empty") +13086 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must have two inouts" "F - test-copy-object-with-no-input: error message") +13087 # check that stop(1) was called +13088 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-no-input: exit status") +13089 # don't restore from ebp +13090 81 0/subop/add %esp 8/imm32 +13091 # . epilogue +13092 5d/pop-to-ebp +13093 c3/return +13094 +13095 test-copy-object-with-too-many-inouts: +13096 # . prologue +13097 55/push-ebp +13098 89/<- %ebp 4/r32/esp +13099 # setup +13100 (clear-stream _test-input-stream) +13101 (clear-stream $_test-input-buffered-file->buffer) +13102 (clear-stream _test-output-stream) +13103 (clear-stream $_test-output-buffered-file->buffer) +13104 (clear-stream _test-error-stream) +13105 (clear-stream $_test-error-buffered-file->buffer) +13106 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13107 68/push 0/imm32 +13108 68/push 0/imm32 13109 89/<- %edx 4/r32/esp -13110 (flush _test-output-buffered-file) -13111 (flush _test-error-buffered-file) -13112 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13118 # check output -13119 (check-stream-equal _test-output-stream "" "F - test-populate-with-output: output should be empty") -13120 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate' must not have any outputs" "F - test-populate-with-output: error message") -13121 # check that stop(1) was called -13122 (check-ints-equal *(edx+4) 2 "F - test-populate-with-output: exit status") -13123 # don't restore from ebp -13124 81 0/subop/add %esp 8/imm32 -13125 # . epilogue -13126 5d/pop-to-ebp -13127 c3/return -13128 -13129 test-populate-non-addr: -13130 # . prologue -13131 55/push-ebp -13132 89/<- %ebp 4/r32/esp -13133 # setup -13134 (clear-stream _test-input-stream) -13135 (clear-stream $_test-input-buffered-file->buffer) -13136 (clear-stream _test-output-stream) -13137 (clear-stream $_test-output-buffered-file->buffer) -13138 (clear-stream _test-error-stream) -13139 (clear-stream $_test-error-buffered-file->buffer) -13140 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13141 68/push 0/imm32 -13142 68/push 0/imm32 -13143 89/<- %edx 4/r32/esp -13144 (tailor-exit-descriptor %edx 0x10) -13145 # -13146 (write _test-input-stream "fn foo {\n") -13147 (write _test-input-stream " var y: (handle int)\n") -13148 (write _test-input-stream " populate y, 3\n") -13149 (write _test-input-stream "}\n") -13150 # convert -13151 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13152 # registers except esp clobbered at this point -13153 # restore ed +13110 (tailor-exit-descriptor %edx 0x10) +13111 # +13112 (write _test-input-stream "fn foo {\n") +13113 (write _test-input-stream " var x: (addr boolean)\n") +13114 (write _test-input-stream " copy-object x, x, x\n") +13115 (write _test-input-stream "}\n") +13116 # convert +13117 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13118 # registers except esp clobbered at this point +13119 # restore ed +13120 89/<- %edx 4/r32/esp +13121 (flush _test-output-buffered-file) +13122 (flush _test-error-buffered-file) +13123 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13129 # check output +13130 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-too-many-inouts: output should be empty") +13131 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must have two inouts" "F - test-copy-object-with-too-many-inouts: error message") +13132 # check that stop(1) was called +13133 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-too-many-inouts: exit status") +13134 # don't restore from ebp +13135 81 0/subop/add %esp 8/imm32 +13136 # . epilogue +13137 5d/pop-to-ebp +13138 c3/return +13139 +13140 test-copy-object-with-output: +13141 # . prologue +13142 55/push-ebp +13143 89/<- %ebp 4/r32/esp +13144 # setup +13145 (clear-stream _test-input-stream) +13146 (clear-stream $_test-input-buffered-file->buffer) +13147 (clear-stream _test-output-stream) +13148 (clear-stream $_test-output-buffered-file->buffer) +13149 (clear-stream _test-error-stream) +13150 (clear-stream $_test-error-buffered-file->buffer) +13151 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13152 68/push 0/imm32 +13153 68/push 0/imm32 13154 89/<- %edx 4/r32/esp -13155 (flush _test-output-buffered-file) -13156 (flush _test-error-buffered-file) -13157 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13163 # check output -13164 (check-stream-equal _test-output-stream "" "F - test-populate-non-addr: output must be empty") -13165 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate: first inout 'y' must have type (addr handle array ...)" "F - test-populate-non-addr: error message") -13166 # check that stop(1) was called -13167 (check-ints-equal *(edx+4) 2 "F - test-populate-non-addr: exit status") -13168 # don't restore from ebp -13169 81 0/subop/add %esp 8/imm32 -13170 # . epilogue -13171 5d/pop-to-ebp -13172 c3/return -13173 -13174 test-populate-non-addr-handle: -13175 # . prologue -13176 55/push-ebp -13177 89/<- %ebp 4/r32/esp -13178 # setup -13179 (clear-stream _test-input-stream) -13180 (clear-stream $_test-input-buffered-file->buffer) -13181 (clear-stream _test-output-stream) -13182 (clear-stream $_test-output-buffered-file->buffer) -13183 (clear-stream _test-error-stream) -13184 (clear-stream $_test-error-buffered-file->buffer) -13185 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13186 68/push 0/imm32 -13187 68/push 0/imm32 -13188 89/<- %edx 4/r32/esp -13189 (tailor-exit-descriptor %edx 0x10) -13190 # -13191 (write _test-input-stream "fn foo {\n") -13192 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") -13193 (write _test-input-stream " populate y, 3\n") -13194 (write _test-input-stream "}\n") -13195 # convert -13196 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13197 # registers except esp clobbered at this point -13198 # restore ed -13199 89/<- %edx 4/r32/esp -13200 (flush _test-output-buffered-file) -13201 (flush _test-error-buffered-file) -13202 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13208 # check output -13209 (check-stream-equal _test-output-stream "" "F - test-populate-non-addr-handle: output should be empty") -13210 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate: first inout 'y' must have type (addr handle array ...)" "F - test-populate-non-addr-handle: error message") -13211 # check that stop(1) was called -13212 (check-ints-equal *(edx+4) 2 "F - test-populate-non-addr-handle: exit status") -13213 # don't restore from ebp -13214 81 0/subop/add %esp 8/imm32 -13215 # . epilogue -13216 5d/pop-to-ebp -13217 c3/return -13218 -13219 test-populate-non-addr-handle-array: -13220 # . prologue -13221 55/push-ebp -13222 89/<- %ebp 4/r32/esp -13223 # setup -13224 (clear-stream _test-input-stream) -13225 (clear-stream $_test-input-buffered-file->buffer) -13226 (clear-stream _test-output-stream) -13227 (clear-stream $_test-output-buffered-file->buffer) -13228 (clear-stream _test-error-stream) -13229 (clear-stream $_test-error-buffered-file->buffer) -13230 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13231 68/push 0/imm32 -13232 68/push 0/imm32 -13233 89/<- %edx 4/r32/esp -13234 (tailor-exit-descriptor %edx 0x10) -13235 # -13236 (write _test-input-stream "fn foo {\n") -13237 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") -13238 (write _test-input-stream " populate y, 3\n") -13239 (write _test-input-stream "}\n") -13240 # convert -13241 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13242 # registers except esp clobbered at this point -13243 # restore ed -13244 89/<- %edx 4/r32/esp -13245 (flush _test-output-buffered-file) -13246 (flush _test-error-buffered-file) -13247 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13253 # check output -13254 (check-stream-equal _test-output-stream "" "F - test-populate-non-addr-handle-array: output should be empty") -13255 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate: first inout 'y' must have type (addr handle array ...)" "F - test-populate-non-addr-handle-array: error message") -13256 # check that stop(1) was called -13257 (check-ints-equal *(edx+4) 2 "F - test-populate-non-addr-handle-array: exit status") -13258 # don't restore from ebp -13259 81 0/subop/add %esp 8/imm32 -13260 # . epilogue -13261 5d/pop-to-ebp -13262 c3/return -13263 -13264 test-populate-deref-address: -13265 # . prologue -13266 55/push-ebp -13267 89/<- %ebp 4/r32/esp -13268 # setup -13269 (clear-stream _test-input-stream) -13270 (clear-stream $_test-input-buffered-file->buffer) -13271 (clear-stream _test-output-stream) -13272 (clear-stream $_test-output-buffered-file->buffer) -13273 # -13274 (write _test-input-stream "fn foo {\n") -13275 (write _test-input-stream " var y/ecx: (addr addr handle array int) <- copy 0\n") -13276 (write _test-input-stream " populate *y, 3\n") -13277 (write _test-input-stream "}\n") -13278 # convert -13279 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -13280 (flush _test-output-buffered-file) -13281 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13287 # not bothering checking output -13288 (check-next-stream-line-equal _test-error-stream "" "F - test-populate-deref-address: error message") -13289 # . epilogue -13290 5d/pop-to-ebp -13291 c3/return -13292 -13293 test-populate-stream-with-no-inout: -13294 # . prologue -13295 55/push-ebp -13296 89/<- %ebp 4/r32/esp -13297 # setup -13298 (clear-stream _test-input-stream) -13299 (clear-stream $_test-input-buffered-file->buffer) -13300 (clear-stream _test-output-stream) -13301 (clear-stream $_test-output-buffered-file->buffer) -13302 (clear-stream _test-error-stream) -13303 (clear-stream $_test-error-buffered-file->buffer) -13304 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13305 68/push 0/imm32 -13306 68/push 0/imm32 -13307 89/<- %edx 4/r32/esp -13308 (tailor-exit-descriptor %edx 0x10) -13309 # -13310 (write _test-input-stream "fn foo {\n") -13311 (write _test-input-stream " populate-stream\n") -13312 (write _test-input-stream "}\n") -13313 # convert -13314 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13315 # registers except esp clobbered at this point -13316 # restore ed -13317 89/<- %edx 4/r32/esp -13318 (flush _test-output-buffered-file) -13319 (flush _test-error-buffered-file) -13320 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13326 # check output -13327 (check-stream-equal _test-output-stream "" "F - test-populate-stream-with-no-inout: output should be empty") -13328 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate-stream' must have two inouts" "F - test-populate-stream-with-no-inout: error message") -13329 # check that stop(1) was called -13330 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-with-no-inout: exit status") -13331 # don't restore from ebp -13332 81 0/subop/add %esp 8/imm32 -13333 # . epilogue -13334 5d/pop-to-ebp -13335 c3/return -13336 -13337 test-populate-stream-with-too-many-inouts: -13338 # . prologue -13339 55/push-ebp -13340 89/<- %ebp 4/r32/esp -13341 # setup -13342 (clear-stream _test-input-stream) -13343 (clear-stream $_test-input-buffered-file->buffer) -13344 (clear-stream _test-output-stream) -13345 (clear-stream $_test-output-buffered-file->buffer) -13346 (clear-stream _test-error-stream) -13347 (clear-stream $_test-error-buffered-file->buffer) -13348 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13349 68/push 0/imm32 -13350 68/push 0/imm32 -13351 89/<- %edx 4/r32/esp -13352 (tailor-exit-descriptor %edx 0x10) -13353 # -13354 (write _test-input-stream "fn foo {\n") -13355 (write _test-input-stream " var x: (addr handle int)\n") -13356 (write _test-input-stream " populate-stream x, 3, 0\n") -13357 (write _test-input-stream "}\n") -13358 # convert -13359 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13360 # registers except esp clobbered at this point -13361 # restore ed -13362 89/<- %edx 4/r32/esp -13363 (flush _test-output-buffered-file) -13364 (flush _test-error-buffered-file) -13365 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13371 # check output -13372 (check-stream-equal _test-output-stream "" "F - test-populate-stream-with-too-many-inouts: output should be empty") -13373 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate-stream' must have two inouts" "F - test-populate-stream-with-too-many-inouts: error message") -13374 # check that stop(1) was called -13375 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-with-too-many-inouts: exit status") -13376 # don't restore from ebp -13377 81 0/subop/add %esp 8/imm32 -13378 # . epilogue -13379 5d/pop-to-ebp -13380 c3/return -13381 -13382 test-populate-stream-with-output: -13383 # . prologue -13384 55/push-ebp -13385 89/<- %ebp 4/r32/esp -13386 # setup -13387 (clear-stream _test-input-stream) -13388 (clear-stream $_test-input-buffered-file->buffer) -13389 (clear-stream _test-output-stream) -13390 (clear-stream $_test-output-buffered-file->buffer) -13391 (clear-stream _test-error-stream) -13392 (clear-stream $_test-error-buffered-file->buffer) -13393 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13394 68/push 0/imm32 -13395 68/push 0/imm32 -13396 89/<- %edx 4/r32/esp -13397 (tailor-exit-descriptor %edx 0x10) -13398 # -13399 (write _test-input-stream "fn foo {\n") -13400 (write _test-input-stream " var x/eax: boolean <- copy 0\n") -13401 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") -13402 (write _test-input-stream " x <- populate-stream y\n") -13403 (write _test-input-stream "}\n") -13404 # convert -13405 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13406 # registers except esp clobbered at this point -13407 # restore ed -13408 89/<- %edx 4/r32/esp -13409 (flush _test-output-buffered-file) -13410 (flush _test-error-buffered-file) -13411 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13417 # check output -13418 (check-stream-equal _test-output-stream "" "F - test-populate-stream-with-output: output should be empty") -13419 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate-stream' must not have any outputs" "F - test-populate-stream-with-output: error message") -13420 # check that stop(1) was called -13421 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-with-output: exit status") -13422 # don't restore from ebp -13423 81 0/subop/add %esp 8/imm32 -13424 # . epilogue -13425 5d/pop-to-ebp -13426 c3/return -13427 -13428 test-populate-stream-non-addr: -13429 # . prologue -13430 55/push-ebp -13431 89/<- %ebp 4/r32/esp -13432 # setup -13433 (clear-stream _test-input-stream) -13434 (clear-stream $_test-input-buffered-file->buffer) -13435 (clear-stream _test-output-stream) -13436 (clear-stream $_test-output-buffered-file->buffer) -13437 (clear-stream _test-error-stream) -13438 (clear-stream $_test-error-buffered-file->buffer) -13439 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13440 68/push 0/imm32 -13441 68/push 0/imm32 -13442 89/<- %edx 4/r32/esp -13443 (tailor-exit-descriptor %edx 0x10) -13444 # -13445 (write _test-input-stream "fn foo {\n") -13446 (write _test-input-stream " var y: (handle int)\n") -13447 (write _test-input-stream " populate-stream y, 3\n") -13448 (write _test-input-stream "}\n") -13449 # convert -13450 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13451 # registers except esp clobbered at this point -13452 # restore ed -13453 89/<- %edx 4/r32/esp -13454 (flush _test-output-buffered-file) -13455 (flush _test-error-buffered-file) -13456 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13462 # check output -13463 (check-stream-equal _test-output-stream "" "F - test-populate-stream-non-addr: output must be empty") -13464 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate-stream: first inout 'y' must have type (addr handle stream ...)" "F - test-populate-stream-non-addr: error message") -13465 # check that stop(1) was called -13466 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-non-addr: exit status") -13467 # don't restore from ebp -13468 81 0/subop/add %esp 8/imm32 -13469 # . epilogue -13470 5d/pop-to-ebp -13471 c3/return -13472 -13473 test-populate-stream-non-addr-handle: -13474 # . prologue -13475 55/push-ebp -13476 89/<- %ebp 4/r32/esp -13477 # setup -13478 (clear-stream _test-input-stream) -13479 (clear-stream $_test-input-buffered-file->buffer) -13480 (clear-stream _test-output-stream) -13481 (clear-stream $_test-output-buffered-file->buffer) -13482 (clear-stream _test-error-stream) -13483 (clear-stream $_test-error-buffered-file->buffer) -13484 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13485 68/push 0/imm32 -13486 68/push 0/imm32 -13487 89/<- %edx 4/r32/esp -13488 (tailor-exit-descriptor %edx 0x10) -13489 # -13490 (write _test-input-stream "fn foo {\n") -13491 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") -13492 (write _test-input-stream " populate-stream y, 3\n") -13493 (write _test-input-stream "}\n") -13494 # convert -13495 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13496 # registers except esp clobbered at this point -13497 # restore ed -13498 89/<- %edx 4/r32/esp -13499 (flush _test-output-buffered-file) -13500 (flush _test-error-buffered-file) -13501 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13507 # check output -13508 (check-stream-equal _test-output-stream "" "F - test-populate-stream-non-addr-handle: output should be empty") -13509 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate-stream: first inout 'y' must have type (addr handle stream ...)" "F - test-populate-stream-non-addr-handle: error message") -13510 # check that stop(1) was called -13511 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-non-addr-handle: exit status") -13512 # don't restore from ebp -13513 81 0/subop/add %esp 8/imm32 -13514 # . epilogue -13515 5d/pop-to-ebp -13516 c3/return -13517 -13518 test-populate-stream-non-addr-handle-stream: -13519 # . prologue -13520 55/push-ebp -13521 89/<- %ebp 4/r32/esp -13522 # setup -13523 (clear-stream _test-input-stream) -13524 (clear-stream $_test-input-buffered-file->buffer) -13525 (clear-stream _test-output-stream) -13526 (clear-stream $_test-output-buffered-file->buffer) -13527 (clear-stream _test-error-stream) -13528 (clear-stream $_test-error-buffered-file->buffer) -13529 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) -13530 68/push 0/imm32 -13531 68/push 0/imm32 -13532 89/<- %edx 4/r32/esp -13533 (tailor-exit-descriptor %edx 0x10) -13534 # -13535 (write _test-input-stream "fn foo {\n") -13536 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") -13537 (write _test-input-stream " populate-stream y, 3\n") -13538 (write _test-input-stream "}\n") -13539 # convert -13540 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) -13541 # registers except esp clobbered at this point -13542 # restore ed -13543 89/<- %edx 4/r32/esp -13544 (flush _test-output-buffered-file) -13545 (flush _test-error-buffered-file) -13546 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13552 # check output -13553 (check-stream-equal _test-output-stream "" "F - test-populate-stream-non-addr-handle-stream: output should be empty") -13554 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate-stream: first inout 'y' must have type (addr handle stream ...)" "F - test-populate-stream-non-addr-handle-stream: error message") -13555 # check that stop(1) was called -13556 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-non-addr-handle-stream: exit status") -13557 # don't restore from ebp -13558 81 0/subop/add %esp 8/imm32 -13559 # . epilogue -13560 5d/pop-to-ebp -13561 c3/return -13562 -13563 test-populate-stream-deref-address: -13564 # . prologue -13565 55/push-ebp -13566 89/<- %ebp 4/r32/esp -13567 # setup -13568 (clear-stream _test-input-stream) -13569 (clear-stream $_test-input-buffered-file->buffer) -13570 (clear-stream _test-output-stream) -13571 (clear-stream $_test-output-buffered-file->buffer) -13572 # -13573 (write _test-input-stream "fn foo {\n") -13574 (write _test-input-stream " var y/ecx: (addr addr handle stream int) <- copy 0\n") -13575 (write _test-input-stream " populate-stream *y, 3\n") -13576 (write _test-input-stream "}\n") -13577 # convert -13578 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) -13579 (flush _test-output-buffered-file) -13580 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13586 # not bothering checking output -13587 (check-next-stream-line-equal _test-error-stream "" "F - test-populate-stream-deref-address: error message") -13588 # . epilogue -13589 5d/pop-to-ebp -13590 c3/return -13591 -13592 ####################################################### -13593 # Parsing -13594 ####################################################### -13595 -13596 == data -13597 -13598 # Global state added to each var record when parsing a function -13599 Next-block-index: # (addr int) -13600 1/imm32 -13601 -13602 Curr-block-depth: # (addr int) -13603 1/imm32 -13604 -13605 == code -13606 -13607 parse-mu: # in: (addr buffered-file), err: (addr buffered-file), ed: (addr exit-descriptor) -13608 # pseudocode -13609 # var curr-function: (addr handle function) = Program->functions -13610 # var curr-signature: (addr handle function) = Program->signatures -13611 # var curr-type: (addr handle typeinfo) = Program->types -13612 # var line: (stream byte 512) -13613 # var word-slice: slice -13614 # while true # line loop -13615 # clear-stream(line) -13616 # read-line-buffered(in, line) -13617 # if (line->write == 0) break # end of file -13618 # word-slice = next-mu-token(line) -13619 # if slice-empty?(word-slice) # end of line -13620 # continue -13621 # else if slice-starts-with?(word-slice, "#") # comment -13622 # continue # end of line -13623 # else if slice-equal?(word-slice, "fn") -13624 # var new-function: (handle function) = allocate(function) -13625 # var vars: (stack live-var 256) -13626 # populate-mu-function-header(line, new-function, vars) -13627 # populate-mu-function-body(in, new-function, vars) -13628 # assert(vars->top == 0) -13629 # *curr-function = new-function -13630 # curr-function = &new-function->next -13631 # else if slice-equal?(word-slice, "sig") -13632 # var new-function: (handle function) = allocate(function) -13633 # populate-mu-function-signature(line, new-function) -13634 # *curr-signature = new-function -13635 # curr-signature = &new-function->next -13636 # else if slice-equal?(word-slice, "type") -13637 # word-slice = next-mu-token(line) -13638 # type-id = pos-or-insert-slice(Type-id, word-slice) -13639 # var new-type: (handle typeinfo) = find-or-create-typeinfo(type-id) -13640 # assert(next-word(line) == "{") -13641 # populate-mu-type(in, new-type) -13642 # else -13643 # abort() -13644 # -13645 # . prologue -13646 55/push-ebp -13647 89/<- %ebp 4/r32/esp -13648 # var curr-signature: (addr handle function) at *(ebp-4) -13649 68/push _Program-signatures/imm32 -13650 # . save registers -13651 50/push-eax -13652 51/push-ecx -13653 52/push-edx -13654 53/push-ebx -13655 56/push-esi -13656 57/push-edi -13657 # var line/ecx: (stream byte 512) -13658 81 5/subop/subtract %esp 0x200/imm32 -13659 68/push 0x200/imm32/size -13660 68/push 0/imm32/read -13661 68/push 0/imm32/write -13662 89/<- %ecx 4/r32/esp -13663 # var word-slice/edx: slice -13664 68/push 0/imm32/end -13665 68/push 0/imm32/start -13666 89/<- %edx 4/r32/esp -13667 # var curr-function/edi: (addr handle function) -13668 bf/copy-to-edi _Program-functions/imm32 -13669 # var vars/ebx: (stack live-var 256) -13670 81 5/subop/subtract %esp 0xc00/imm32 -13671 68/push 0xc00/imm32/size -13672 68/push 0/imm32/top -13673 89/<- %ebx 4/r32/esp -13674 { -13675 $parse-mu:line-loop: -13676 (clear-stream %ecx) -13677 (read-line-buffered *(ebp+8) %ecx) -13678 # if (line->write == 0) break -13679 81 7/subop/compare *ecx 0/imm32 -13680 0f 84/jump-if-= break/disp32 -13681 +-- 6 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -13687 (next-mu-token %ecx %edx) -13688 # if slice-empty?(word-slice) continue -13689 (slice-empty? %edx) # => eax -13690 3d/compare-eax-and 0/imm32/false -13691 0f 85/jump-if-!= loop/disp32 -13692 # if (*word-slice->start == "#") continue -13693 # . eax = *word-slice->start -13694 8b/-> *edx 0/r32/eax -13695 8a/copy-byte *eax 0/r32/AL -13696 81 4/subop/and %eax 0xff/imm32 -13697 # . if (eax == '#') continue -13698 3d/compare-eax-and 0x23/imm32/hash -13699 0f 84/jump-if-= loop/disp32 -13700 # if (slice-equal?(word-slice, "fn")) parse a function -13701 { -13702 $parse-mu:fn: -13703 (slice-equal? %edx "fn") # => eax -13704 3d/compare-eax-and 0/imm32/false -13705 0f 84/jump-if-= break/disp32 -13706 # var new-function/esi: (handle function) -13707 68/push 0/imm32 -13708 68/push 0/imm32 -13709 89/<- %esi 4/r32/esp -13710 # populate-mu-function(line, in, vars, new-function) -13711 (allocate Heap *Function-size %esi) -13712 # var new-function-addr/eax: (addr function) -13713 (lookup *esi *(esi+4)) # => eax -13714 # initialize vars -13715 (clear-stack %ebx) -13716 # -13717 (populate-mu-function-header %ecx %eax %ebx *(ebp+0xc) *(ebp+0x10)) -13718 (populate-mu-function-body *(ebp+8) %eax %ebx *(ebp+0xc) *(ebp+0x10)) -13719 # *curr-function = new-function -13720 8b/-> *esi 0/r32/eax -13721 89/<- *edi 0/r32/eax -13722 8b/-> *(esi+4) 0/r32/eax -13723 89/<- *(edi+4) 0/r32/eax -13724 # curr-function = &new-function->next -13725 # . var tmp/eax: (addr function) = lookup(new-function) -13726 (lookup *esi *(esi+4)) # => eax -13727 # . curr-function = &tmp->next -13728 8d/copy-address *(eax+0x20) 7/r32/edi # Function-next -13729 # reclaim new-function -13730 81 0/subop/add %esp 8/imm32 -13731 # -13732 e9/jump $parse-mu:line-loop/disp32 -13733 } -13734 # if (slice-equal?(word-slice, "sig")) parse a function signature -13735 # Function signatures are for providing types to SubX functions. -13736 { -13737 $parse-mu:sig: -13738 (slice-equal? %edx "sig") # => eax -13739 3d/compare-eax-and 0/imm32/false -13740 0f 84/jump-if-= break/disp32 -13741 # edi = curr-function -13742 57/push-edi -13743 8b/-> *(ebp-4) 7/r32/edi -13744 # var new-function/esi: (handle function) -13745 68/push 0/imm32 -13746 68/push 0/imm32 -13747 89/<- %esi 4/r32/esp -13748 # populate-mu-function(line, in, vars, new-function) -13749 (allocate Heap *Function-size %esi) -13750 # var new-function-addr/eax: (addr function) -13751 (lookup *esi *(esi+4)) # => eax -13752 # -13753 (populate-mu-function-signature %ecx %eax *(ebp+0xc) *(ebp+0x10)) -13754 # *curr-signature = new-function -13755 8b/-> *esi 0/r32/eax -13756 89/<- *edi 0/r32/eax -13757 8b/-> *(esi+4) 0/r32/eax -13758 89/<- *(edi+4) 0/r32/eax -13759 # curr-signature = &new-function->next -13760 # . var tmp/eax: (addr function) = lookup(new-function) -13761 (lookup *esi *(esi+4)) # => eax -13762 # . curr-function = &tmp->next -13763 8d/copy-address *(eax+0x20) 7/r32/edi # Function-next -13764 # reclaim new-function -13765 81 0/subop/add %esp 8/imm32 -13766 # save curr-function -13767 89/<- *(ebp-4) 7/r32/edi -13768 # restore edi -13769 5f/pop-to-edi -13770 # -13771 e9/jump $parse-mu:line-loop/disp32 -13772 } -13773 # if (slice-equal?(word-slice, "type")) parse a type (struct/record) definition -13774 { -13775 $parse-mu:type: -13776 (slice-equal? %edx "type") # => eax -13777 3d/compare-eax-and 0/imm32 -13778 0f 84/jump-if-= break/disp32 -13779 (next-mu-token %ecx %edx) -13780 # var type-id/eax: int -13781 (pos-or-insert-slice Type-id %edx) # => eax -13782 # spill -13783 51/push-ecx -13784 # var new-type/ecx: (handle typeinfo) -13785 68/push 0/imm32 -13786 68/push 0/imm32 -13787 89/<- %ecx 4/r32/esp -13788 (find-or-create-typeinfo %eax %ecx) -13789 # -13790 (lookup *ecx *(ecx+4)) # => eax -13791 # TODO: ensure that 'line' has nothing else but '{' -13792 #? (dump-typeinfos "=== aaa\n") -13793 (populate-mu-type *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10)) # => eax -13794 #? (dump-typeinfos "=== zzz\n") -13795 # reclaim new-type -13796 81 0/subop/add %esp 8/imm32 -13797 # restore -13798 59/pop-to-ecx -13799 e9/jump $parse-mu:line-loop/disp32 -13800 } -13801 # otherwise abort -13802 e9/jump $parse-mu:error1/disp32 -13803 } # end line loop -13804 $parse-mu:end: -13805 # . reclaim locals -13806 81 0/subop/add %esp 0x20c/imm32 # line -13807 81 0/subop/add %esp 0xc08/imm32 # vars -13808 81 0/subop/add %esp 8/imm32 -13809 # . restore registers -13810 5f/pop-to-edi -13811 5e/pop-to-esi -13812 5b/pop-to-ebx -13813 5a/pop-to-edx -13814 59/pop-to-ecx -13815 58/pop-to-eax -13816 # . reclaim local -13817 81 0/subop/add %esp 4/imm32 -13818 # . epilogue -13819 89/<- %esp 5/r32/ebp -13820 5d/pop-to-ebp -13821 c3/return -13822 -13823 $parse-mu:error1: -13824 # error("unexpected top-level command: " word-slice "\n") -13825 (write-buffered *(ebp+0xc) "unexpected top-level command: ") -13826 (write-slice-buffered *(ebp+0xc) %edx) -13827 (write-buffered *(ebp+0xc) "\n") -13828 (flush *(ebp+0xc)) -13829 (stop *(ebp+0x10) 1) -13830 # never gets here +13155 (tailor-exit-descriptor %edx 0x10) +13156 # +13157 (write _test-input-stream "fn foo {\n") +13158 (write _test-input-stream " var x/eax: (addr boolean) <- copy 0\n") +13159 (write _test-input-stream " var y/ecx: (addr boolean) <- copy 0\n") +13160 (write _test-input-stream " x <- copy-object x, y\n") +13161 (write _test-input-stream "}\n") +13162 # convert +13163 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13164 # registers except esp clobbered at this point +13165 # restore ed +13166 89/<- %edx 4/r32/esp +13167 (flush _test-output-buffered-file) +13168 (flush _test-error-buffered-file) +13169 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13175 # check output +13176 (check-stream-equal _test-output-stream "" "F - test-copy-object-with-output: output should be empty") +13177 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'copy-object' must not have any outputs" "F - test-copy-object-with-output: error message") +13178 # check that stop(1) was called +13179 (check-ints-equal *(edx+4) 2 "F - test-copy-object-with-output: exit status") +13180 # don't restore from ebp +13181 81 0/subop/add %esp 8/imm32 +13182 # . epilogue +13183 5d/pop-to-ebp +13184 c3/return +13185 +13186 test-copy-object-deref-address: +13187 # . prologue +13188 55/push-ebp +13189 89/<- %ebp 4/r32/esp +13190 # setup +13191 (clear-stream _test-input-stream) +13192 (clear-stream $_test-input-buffered-file->buffer) +13193 (clear-stream _test-output-stream) +13194 (clear-stream $_test-output-buffered-file->buffer) +13195 # +13196 (write _test-input-stream "fn foo {\n") +13197 (write _test-input-stream " var x/eax: (addr int) <- copy 0\n") +13198 (write _test-input-stream " var y/ecx: (addr addr int) <- copy 0\n") +13199 (write _test-input-stream " copy-object *y, x\n") +13200 (write _test-input-stream "}\n") +13201 # convert +13202 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +13203 (flush _test-output-buffered-file) +13204 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13210 # not bothering checking output +13211 (check-next-stream-line-equal _test-error-stream "" "F - test-copy-object-deref-address: error message") +13212 # . epilogue +13213 5d/pop-to-ebp +13214 c3/return +13215 +13216 test-copy-object-non-addr: +13217 # . prologue +13218 55/push-ebp +13219 89/<- %ebp 4/r32/esp +13220 # setup +13221 (clear-stream _test-input-stream) +13222 (clear-stream $_test-input-buffered-file->buffer) +13223 (clear-stream _test-output-stream) +13224 (clear-stream $_test-output-buffered-file->buffer) +13225 (clear-stream _test-error-stream) +13226 (clear-stream $_test-error-buffered-file->buffer) +13227 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13228 68/push 0/imm32 +13229 68/push 0/imm32 +13230 89/<- %edx 4/r32/esp +13231 (tailor-exit-descriptor %edx 0x10) +13232 # +13233 (write _test-input-stream "fn foo {\n") +13234 (write _test-input-stream " var x: int\n") +13235 (write _test-input-stream " var y: int\n") +13236 (write _test-input-stream " copy-object y, x\n") +13237 (write _test-input-stream "}\n") +13238 # convert +13239 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13240 # registers except esp clobbered at this point +13241 # restore ed +13242 89/<- %edx 4/r32/esp +13243 (flush _test-output-buffered-file) +13244 (flush _test-error-buffered-file) +13245 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13251 # check output +13252 (check-stream-equal _test-output-stream "" "F - test-copy-object-non-addr: output should be empty") +13253 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-object: two inouts with identical addr types expected" "F - test-copy-object-non-addr: error message") +13254 # check that stop(1) was called +13255 (check-ints-equal *(edx+4) 2 "F - test-copy-object-non-addr: exit status") +13256 # don't restore from ebp +13257 81 0/subop/add %esp 8/imm32 +13258 # . epilogue +13259 5d/pop-to-ebp +13260 c3/return +13261 +13262 test-copy-object-non-equal: +13263 # . prologue +13264 55/push-ebp +13265 89/<- %ebp 4/r32/esp +13266 # setup +13267 (clear-stream _test-input-stream) +13268 (clear-stream $_test-input-buffered-file->buffer) +13269 (clear-stream _test-output-stream) +13270 (clear-stream $_test-output-buffered-file->buffer) +13271 (clear-stream _test-error-stream) +13272 (clear-stream $_test-error-buffered-file->buffer) +13273 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13274 68/push 0/imm32 +13275 68/push 0/imm32 +13276 89/<- %edx 4/r32/esp +13277 (tailor-exit-descriptor %edx 0x10) +13278 # +13279 (write _test-input-stream "fn foo {\n") +13280 (write _test-input-stream " var x: (addr int)\n") +13281 (write _test-input-stream " var y: (addr boolean)\n") +13282 (write _test-input-stream " copy-object y, x\n") +13283 (write _test-input-stream "}\n") +13284 # convert +13285 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13286 # registers except esp clobbered at this point +13287 # restore ed +13288 89/<- %edx 4/r32/esp +13289 (flush _test-output-buffered-file) +13290 (flush _test-error-buffered-file) +13291 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13297 # check output +13298 (check-stream-equal _test-output-stream "" "F - test-copy-object-non-equal: output should be empty") +13299 (check-next-stream-line-equal _test-error-stream "fn foo: stmt copy-object: two inouts with identical addr types expected" "F - test-copy-object-non-equal: error message") +13300 # check that stop(1) was called +13301 (check-ints-equal *(edx+4) 2 "F - test-copy-object-non-equal: exit status") +13302 # don't restore from ebp +13303 81 0/subop/add %esp 8/imm32 +13304 # . epilogue +13305 5d/pop-to-ebp +13306 c3/return +13307 +13308 test-allocate-with-no-inout: +13309 # . prologue +13310 55/push-ebp +13311 89/<- %ebp 4/r32/esp +13312 # setup +13313 (clear-stream _test-input-stream) +13314 (clear-stream $_test-input-buffered-file->buffer) +13315 (clear-stream _test-output-stream) +13316 (clear-stream $_test-output-buffered-file->buffer) +13317 (clear-stream _test-error-stream) +13318 (clear-stream $_test-error-buffered-file->buffer) +13319 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13320 68/push 0/imm32 +13321 68/push 0/imm32 +13322 89/<- %edx 4/r32/esp +13323 (tailor-exit-descriptor %edx 0x10) +13324 # +13325 (write _test-input-stream "fn foo {\n") +13326 (write _test-input-stream " allocate\n") +13327 (write _test-input-stream "}\n") +13328 # convert +13329 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13330 # registers except esp clobbered at this point +13331 # restore ed +13332 89/<- %edx 4/r32/esp +13333 (flush _test-output-buffered-file) +13334 (flush _test-error-buffered-file) +13335 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13341 # check output +13342 (check-stream-equal _test-output-stream "" "F - test-allocate-with-no-inout: output should be empty") +13343 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'allocate' must have a single inout" "F - test-allocate-with-no-inout: error message") +13344 # check that stop(1) was called +13345 (check-ints-equal *(edx+4) 2 "F - test-allocate-with-no-inout: exit status") +13346 # don't restore from ebp +13347 81 0/subop/add %esp 8/imm32 +13348 # . epilogue +13349 5d/pop-to-ebp +13350 c3/return +13351 +13352 test-allocate-with-too-many-inouts: +13353 # . prologue +13354 55/push-ebp +13355 89/<- %ebp 4/r32/esp +13356 # setup +13357 (clear-stream _test-input-stream) +13358 (clear-stream $_test-input-buffered-file->buffer) +13359 (clear-stream _test-output-stream) +13360 (clear-stream $_test-output-buffered-file->buffer) +13361 (clear-stream _test-error-stream) +13362 (clear-stream $_test-error-buffered-file->buffer) +13363 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13364 68/push 0/imm32 +13365 68/push 0/imm32 +13366 89/<- %edx 4/r32/esp +13367 (tailor-exit-descriptor %edx 0x10) +13368 # +13369 (write _test-input-stream "fn foo {\n") +13370 (write _test-input-stream " var x: (addr handle int)\n") +13371 (write _test-input-stream " allocate x, 0\n") +13372 (write _test-input-stream "}\n") +13373 # convert +13374 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13375 # registers except esp clobbered at this point +13376 # restore ed +13377 89/<- %edx 4/r32/esp +13378 (flush _test-output-buffered-file) +13379 (flush _test-error-buffered-file) +13380 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13386 # check output +13387 (check-stream-equal _test-output-stream "" "F - test-allocate-with-too-many-inouts: output should be empty") +13388 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'allocate' must have a single inout" "F - test-allocate-with-too-many-inouts: error message") +13389 # check that stop(1) was called +13390 (check-ints-equal *(edx+4) 2 "F - test-allocate-with-too-many-inouts: exit status") +13391 # don't restore from ebp +13392 81 0/subop/add %esp 8/imm32 +13393 # . epilogue +13394 5d/pop-to-ebp +13395 c3/return +13396 +13397 test-allocate-with-output: +13398 # . prologue +13399 55/push-ebp +13400 89/<- %ebp 4/r32/esp +13401 # setup +13402 (clear-stream _test-input-stream) +13403 (clear-stream $_test-input-buffered-file->buffer) +13404 (clear-stream _test-output-stream) +13405 (clear-stream $_test-output-buffered-file->buffer) +13406 (clear-stream _test-error-stream) +13407 (clear-stream $_test-error-buffered-file->buffer) +13408 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13409 68/push 0/imm32 +13410 68/push 0/imm32 +13411 89/<- %edx 4/r32/esp +13412 (tailor-exit-descriptor %edx 0x10) +13413 # +13414 (write _test-input-stream "fn foo {\n") +13415 (write _test-input-stream " var x/eax: boolean <- copy 0\n") +13416 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") +13417 (write _test-input-stream " x <- allocate y\n") +13418 (write _test-input-stream "}\n") +13419 # convert +13420 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13421 # registers except esp clobbered at this point +13422 # restore ed +13423 89/<- %edx 4/r32/esp +13424 (flush _test-output-buffered-file) +13425 (flush _test-error-buffered-file) +13426 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13432 # check output +13433 (check-stream-equal _test-output-stream "" "F - test-allocate-with-output: output should be empty") +13434 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'allocate' must not have any outputs" "F - test-allocate-with-output: error message") +13435 # check that stop(1) was called +13436 (check-ints-equal *(edx+4) 2 "F - test-allocate-with-output: exit status") +13437 # don't restore from ebp +13438 81 0/subop/add %esp 8/imm32 +13439 # . epilogue +13440 5d/pop-to-ebp +13441 c3/return +13442 +13443 test-allocate-non-addr: +13444 # . prologue +13445 55/push-ebp +13446 89/<- %ebp 4/r32/esp +13447 # setup +13448 (clear-stream _test-input-stream) +13449 (clear-stream $_test-input-buffered-file->buffer) +13450 (clear-stream _test-output-stream) +13451 (clear-stream $_test-output-buffered-file->buffer) +13452 (clear-stream _test-error-stream) +13453 (clear-stream $_test-error-buffered-file->buffer) +13454 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13455 68/push 0/imm32 +13456 68/push 0/imm32 +13457 89/<- %edx 4/r32/esp +13458 (tailor-exit-descriptor %edx 0x10) +13459 # +13460 (write _test-input-stream "fn foo {\n") +13461 (write _test-input-stream " var y: (handle int)\n") +13462 (write _test-input-stream " allocate y\n") +13463 (write _test-input-stream "}\n") +13464 # convert +13465 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13466 # registers except esp clobbered at this point +13467 # restore ed +13468 89/<- %edx 4/r32/esp +13469 (flush _test-output-buffered-file) +13470 (flush _test-error-buffered-file) +13471 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13477 # check output +13478 (check-stream-equal _test-output-stream "" "F - test-allocate-non-addr: output must be empty") +13479 (check-next-stream-line-equal _test-error-stream "fn foo: stmt allocate: inout 'y' must have type (addr handle ...)" "F - test-allocate-non-addr: error message") +13480 # check that stop(1) was called +13481 (check-ints-equal *(edx+4) 2 "F - test-allocate-non-addr: exit status") +13482 # don't restore from ebp +13483 81 0/subop/add %esp 8/imm32 +13484 # . epilogue +13485 5d/pop-to-ebp +13486 c3/return +13487 +13488 test-allocate-non-addr-handle: +13489 # . prologue +13490 55/push-ebp +13491 89/<- %ebp 4/r32/esp +13492 # setup +13493 (clear-stream _test-input-stream) +13494 (clear-stream $_test-input-buffered-file->buffer) +13495 (clear-stream _test-output-stream) +13496 (clear-stream $_test-output-buffered-file->buffer) +13497 (clear-stream _test-error-stream) +13498 (clear-stream $_test-error-buffered-file->buffer) +13499 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13500 68/push 0/imm32 +13501 68/push 0/imm32 +13502 89/<- %edx 4/r32/esp +13503 (tailor-exit-descriptor %edx 0x10) +13504 # +13505 (write _test-input-stream "fn foo {\n") +13506 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") +13507 (write _test-input-stream " allocate y\n") +13508 (write _test-input-stream "}\n") +13509 # convert +13510 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13511 # registers except esp clobbered at this point +13512 # restore ed +13513 89/<- %edx 4/r32/esp +13514 (flush _test-output-buffered-file) +13515 (flush _test-error-buffered-file) +13516 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13522 # check output +13523 (check-stream-equal _test-output-stream "" "F - test-allocate-non-addr-handle: output should be empty") +13524 (check-next-stream-line-equal _test-error-stream "fn foo: stmt allocate: inout 'y' must have type (addr handle ...)" "F - test-allocate-non-addr-handle: error message") +13525 # check that stop(1) was called +13526 (check-ints-equal *(edx+4) 2 "F - test-allocate-non-addr-handle: exit status") +13527 # don't restore from ebp +13528 81 0/subop/add %esp 8/imm32 +13529 # . epilogue +13530 5d/pop-to-ebp +13531 c3/return +13532 +13533 test-allocate-deref-address: +13534 # . prologue +13535 55/push-ebp +13536 89/<- %ebp 4/r32/esp +13537 # setup +13538 (clear-stream _test-input-stream) +13539 (clear-stream $_test-input-buffered-file->buffer) +13540 (clear-stream _test-output-stream) +13541 (clear-stream $_test-output-buffered-file->buffer) +13542 # +13543 (write _test-input-stream "fn foo {\n") +13544 (write _test-input-stream " var y/ecx: (addr addr handle int) <- copy 0\n") +13545 (write _test-input-stream " allocate *y\n") +13546 (write _test-input-stream "}\n") +13547 # convert +13548 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +13549 (flush _test-output-buffered-file) +13550 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13556 # not bothering checking output +13557 (check-next-stream-line-equal _test-error-stream "" "F - test-allocate-deref-address: error message") +13558 # . epilogue +13559 5d/pop-to-ebp +13560 c3/return +13561 +13562 test-populate-with-no-inout: +13563 # . prologue +13564 55/push-ebp +13565 89/<- %ebp 4/r32/esp +13566 # setup +13567 (clear-stream _test-input-stream) +13568 (clear-stream $_test-input-buffered-file->buffer) +13569 (clear-stream _test-output-stream) +13570 (clear-stream $_test-output-buffered-file->buffer) +13571 (clear-stream _test-error-stream) +13572 (clear-stream $_test-error-buffered-file->buffer) +13573 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13574 68/push 0/imm32 +13575 68/push 0/imm32 +13576 89/<- %edx 4/r32/esp +13577 (tailor-exit-descriptor %edx 0x10) +13578 # +13579 (write _test-input-stream "fn foo {\n") +13580 (write _test-input-stream " populate\n") +13581 (write _test-input-stream "}\n") +13582 # convert +13583 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13584 # registers except esp clobbered at this point +13585 # restore ed +13586 89/<- %edx 4/r32/esp +13587 (flush _test-output-buffered-file) +13588 (flush _test-error-buffered-file) +13589 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13595 # check output +13596 (check-stream-equal _test-output-stream "" "F - test-populate-with-no-inout: output should be empty") +13597 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate' must have two inouts" "F - test-populate-with-no-inout: error message") +13598 # check that stop(1) was called +13599 (check-ints-equal *(edx+4) 2 "F - test-populate-with-no-inout: exit status") +13600 # don't restore from ebp +13601 81 0/subop/add %esp 8/imm32 +13602 # . epilogue +13603 5d/pop-to-ebp +13604 c3/return +13605 +13606 test-populate-with-too-many-inouts: +13607 # . prologue +13608 55/push-ebp +13609 89/<- %ebp 4/r32/esp +13610 # setup +13611 (clear-stream _test-input-stream) +13612 (clear-stream $_test-input-buffered-file->buffer) +13613 (clear-stream _test-output-stream) +13614 (clear-stream $_test-output-buffered-file->buffer) +13615 (clear-stream _test-error-stream) +13616 (clear-stream $_test-error-buffered-file->buffer) +13617 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13618 68/push 0/imm32 +13619 68/push 0/imm32 +13620 89/<- %edx 4/r32/esp +13621 (tailor-exit-descriptor %edx 0x10) +13622 # +13623 (write _test-input-stream "fn foo {\n") +13624 (write _test-input-stream " var x: (addr handle int)\n") +13625 (write _test-input-stream " populate x, 3, 0\n") +13626 (write _test-input-stream "}\n") +13627 # convert +13628 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13629 # registers except esp clobbered at this point +13630 # restore ed +13631 89/<- %edx 4/r32/esp +13632 (flush _test-output-buffered-file) +13633 (flush _test-error-buffered-file) +13634 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13640 # check output +13641 (check-stream-equal _test-output-stream "" "F - test-populate-with-too-many-inouts: output should be empty") +13642 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate' must have two inouts" "F - test-populate-with-too-many-inouts: error message") +13643 # check that stop(1) was called +13644 (check-ints-equal *(edx+4) 2 "F - test-populate-with-too-many-inouts: exit status") +13645 # don't restore from ebp +13646 81 0/subop/add %esp 8/imm32 +13647 # . epilogue +13648 5d/pop-to-ebp +13649 c3/return +13650 +13651 test-populate-with-output: +13652 # . prologue +13653 55/push-ebp +13654 89/<- %ebp 4/r32/esp +13655 # setup +13656 (clear-stream _test-input-stream) +13657 (clear-stream $_test-input-buffered-file->buffer) +13658 (clear-stream _test-output-stream) +13659 (clear-stream $_test-output-buffered-file->buffer) +13660 (clear-stream _test-error-stream) +13661 (clear-stream $_test-error-buffered-file->buffer) +13662 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13663 68/push 0/imm32 +13664 68/push 0/imm32 +13665 89/<- %edx 4/r32/esp +13666 (tailor-exit-descriptor %edx 0x10) +13667 # +13668 (write _test-input-stream "fn foo {\n") +13669 (write _test-input-stream " var x/eax: boolean <- copy 0\n") +13670 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") +13671 (write _test-input-stream " x <- populate y\n") +13672 (write _test-input-stream "}\n") +13673 # convert +13674 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13675 # registers except esp clobbered at this point +13676 # restore ed +13677 89/<- %edx 4/r32/esp +13678 (flush _test-output-buffered-file) +13679 (flush _test-error-buffered-file) +13680 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13686 # check output +13687 (check-stream-equal _test-output-stream "" "F - test-populate-with-output: output should be empty") +13688 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate' must not have any outputs" "F - test-populate-with-output: error message") +13689 # check that stop(1) was called +13690 (check-ints-equal *(edx+4) 2 "F - test-populate-with-output: exit status") +13691 # don't restore from ebp +13692 81 0/subop/add %esp 8/imm32 +13693 # . epilogue +13694 5d/pop-to-ebp +13695 c3/return +13696 +13697 test-populate-non-addr: +13698 # . prologue +13699 55/push-ebp +13700 89/<- %ebp 4/r32/esp +13701 # setup +13702 (clear-stream _test-input-stream) +13703 (clear-stream $_test-input-buffered-file->buffer) +13704 (clear-stream _test-output-stream) +13705 (clear-stream $_test-output-buffered-file->buffer) +13706 (clear-stream _test-error-stream) +13707 (clear-stream $_test-error-buffered-file->buffer) +13708 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13709 68/push 0/imm32 +13710 68/push 0/imm32 +13711 89/<- %edx 4/r32/esp +13712 (tailor-exit-descriptor %edx 0x10) +13713 # +13714 (write _test-input-stream "fn foo {\n") +13715 (write _test-input-stream " var y: (handle int)\n") +13716 (write _test-input-stream " populate y, 3\n") +13717 (write _test-input-stream "}\n") +13718 # convert +13719 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13720 # registers except esp clobbered at this point +13721 # restore ed +13722 89/<- %edx 4/r32/esp +13723 (flush _test-output-buffered-file) +13724 (flush _test-error-buffered-file) +13725 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13731 # check output +13732 (check-stream-equal _test-output-stream "" "F - test-populate-non-addr: output must be empty") +13733 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate: first inout 'y' must have type (addr handle array ...)" "F - test-populate-non-addr: error message") +13734 # check that stop(1) was called +13735 (check-ints-equal *(edx+4) 2 "F - test-populate-non-addr: exit status") +13736 # don't restore from ebp +13737 81 0/subop/add %esp 8/imm32 +13738 # . epilogue +13739 5d/pop-to-ebp +13740 c3/return +13741 +13742 test-populate-non-addr-handle: +13743 # . prologue +13744 55/push-ebp +13745 89/<- %ebp 4/r32/esp +13746 # setup +13747 (clear-stream _test-input-stream) +13748 (clear-stream $_test-input-buffered-file->buffer) +13749 (clear-stream _test-output-stream) +13750 (clear-stream $_test-output-buffered-file->buffer) +13751 (clear-stream _test-error-stream) +13752 (clear-stream $_test-error-buffered-file->buffer) +13753 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13754 68/push 0/imm32 +13755 68/push 0/imm32 +13756 89/<- %edx 4/r32/esp +13757 (tailor-exit-descriptor %edx 0x10) +13758 # +13759 (write _test-input-stream "fn foo {\n") +13760 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") +13761 (write _test-input-stream " populate y, 3\n") +13762 (write _test-input-stream "}\n") +13763 # convert +13764 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13765 # registers except esp clobbered at this point +13766 # restore ed +13767 89/<- %edx 4/r32/esp +13768 (flush _test-output-buffered-file) +13769 (flush _test-error-buffered-file) +13770 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13776 # check output +13777 (check-stream-equal _test-output-stream "" "F - test-populate-non-addr-handle: output should be empty") +13778 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate: first inout 'y' must have type (addr handle array ...)" "F - test-populate-non-addr-handle: error message") +13779 # check that stop(1) was called +13780 (check-ints-equal *(edx+4) 2 "F - test-populate-non-addr-handle: exit status") +13781 # don't restore from ebp +13782 81 0/subop/add %esp 8/imm32 +13783 # . epilogue +13784 5d/pop-to-ebp +13785 c3/return +13786 +13787 test-populate-non-addr-handle-array: +13788 # . prologue +13789 55/push-ebp +13790 89/<- %ebp 4/r32/esp +13791 # setup +13792 (clear-stream _test-input-stream) +13793 (clear-stream $_test-input-buffered-file->buffer) +13794 (clear-stream _test-output-stream) +13795 (clear-stream $_test-output-buffered-file->buffer) +13796 (clear-stream _test-error-stream) +13797 (clear-stream $_test-error-buffered-file->buffer) +13798 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13799 68/push 0/imm32 +13800 68/push 0/imm32 +13801 89/<- %edx 4/r32/esp +13802 (tailor-exit-descriptor %edx 0x10) +13803 # +13804 (write _test-input-stream "fn foo {\n") +13805 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") +13806 (write _test-input-stream " populate y, 3\n") +13807 (write _test-input-stream "}\n") +13808 # convert +13809 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13810 # registers except esp clobbered at this point +13811 # restore ed +13812 89/<- %edx 4/r32/esp +13813 (flush _test-output-buffered-file) +13814 (flush _test-error-buffered-file) +13815 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13821 # check output +13822 (check-stream-equal _test-output-stream "" "F - test-populate-non-addr-handle-array: output should be empty") +13823 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate: first inout 'y' must have type (addr handle array ...)" "F - test-populate-non-addr-handle-array: error message") +13824 # check that stop(1) was called +13825 (check-ints-equal *(edx+4) 2 "F - test-populate-non-addr-handle-array: exit status") +13826 # don't restore from ebp +13827 81 0/subop/add %esp 8/imm32 +13828 # . epilogue +13829 5d/pop-to-ebp +13830 c3/return 13831 -13832 $parse-mu:error2: -13833 # error(vars->top " vars not reclaimed after fn '" new-function->name "'\n") -13834 (write-int32-hex-buffered *(ebp+0xc) *ebx) -13835 (write-buffered *(ebp+0xc) " vars not reclaimed after fn '") -13836 (write-slice-buffered *(ebp+0xc) *eax) # Function-name -13837 (write-buffered *(ebp+0xc) "'\n") -13838 (flush *(ebp+0xc)) -13839 (stop *(ebp+0x10) 1) -13840 # never gets here -13841 -13842 # scenarios considered: -13843 # ✗ fn foo # no block -13844 # ✓ fn foo { -13845 # ✗ fn foo { { -13846 # ✗ fn foo { } -13847 # ✗ fn foo { } { -13848 # ✗ fn foo x { -13849 # ✗ fn foo x: { -13850 # ✓ fn foo x: int { -13851 # ✓ fn foo x: int { -13852 # ✓ fn foo x: int -> _/eax: int { -13853 # TODO: -13854 # disallow outputs of type `(... addr ...)` -13855 # disallow inputs of type `(... addr ... addr ...)` -13856 populate-mu-function-header: # first-line: (addr stream byte), out: (addr function), vars: (addr stack live-var), err: (addr buffered-file), ed: (addr exit-descriptor) -13857 # pseudocode: -13858 # var word-slice: slice -13859 # next-mu-token(first-line, word-slice) -13860 # if slice-empty?(word-slice) abort -13861 # assert(word-slice not in '{' '}' '->') -13862 # out->name = slice-to-string(word-slice) -13863 # ## inouts -13864 # while true -13865 # word-slice = next-mu-token(first-line) -13866 # if slice-empty?(word-slice) abort -13867 # if (word-slice == '{') goto done -13868 # if (word-slice == '->') break -13869 # assert(word-slice != '}') -13870 # var v: (handle var) = parse-var-with-type(word-slice, first-line) -13871 # assert(v->register == null) -13872 # # v->block-depth is implicitly 0 -13873 # out->inouts = append(v, out->inouts) -13874 # push(vars, {v, false}) -13875 # ## outputs -13876 # while true -13877 # word-slice = next-mu-token(first-line) -13878 # if slice-empty?(word-slice) abort -13879 # if (word-slice == '{') break -13880 # assert(word-slice not in '}' '->') -13881 # var v: (handle var) = parse-var-with-type(word-slice, first-line) -13882 # assert(v->register != null) -13883 # assert(v->name == "_") -13884 # out->outputs = append(v, out->outputs) -13885 # done: -13886 # -13887 # . prologue -13888 55/push-ebp -13889 89/<- %ebp 4/r32/esp -13890 # . save registers -13891 50/push-eax -13892 51/push-ecx -13893 52/push-edx -13894 53/push-ebx -13895 57/push-edi -13896 # edi = out -13897 8b/-> *(ebp+0xc) 7/r32/edi -13898 # var word-slice/ecx: slice -13899 68/push 0/imm32/end -13900 68/push 0/imm32/start -13901 89/<- %ecx 4/r32/esp -13902 # var v/ebx: (handle var) -13903 68/push 0/imm32 -13904 68/push 0/imm32 -13905 89/<- %ebx 4/r32/esp -13906 # read function name -13907 (next-mu-token *(ebp+8) %ecx) -13908 # error checking -13909 # if slice-empty?(word-slice) abort -13910 (slice-empty? %ecx) # => eax -13911 3d/compare-eax-and 0/imm32/false -13912 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 -13913 # if (word-slice == '{') abort -13914 (slice-equal? %ecx "{") # => eax -13915 3d/compare-eax-and 0/imm32/false -13916 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 -13917 # if (word-slice == '->') abort -13918 (slice-equal? %ecx "->") # => eax -13919 3d/compare-eax-and 0/imm32/false -13920 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 -13921 # if (word-slice == '}') abort -13922 (slice-equal? %ecx "}") # => eax -13923 3d/compare-eax-and 0/imm32/false -13924 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 -13925 # if word-slice already defined, abort -13926 (function-exists? %ecx) # => eax -13927 3d/compare-eax-and 0/imm32/false -13928 0f 85/jump-if-!= $populate-mu-function-header:error-duplicate/disp32 -13929 # -13930 (slice-starts-with? %ecx "break") # => eax -13931 3d/compare-eax-and 0/imm32/false -13932 0f 85/jump-if-!= $populate-mu-function-header:error-break/disp32 -13933 (slice-starts-with? %ecx "loop") # => eax -13934 3d/compare-eax-and 0/imm32/false -13935 0f 85/jump-if-!= $populate-mu-function-header:error-loop/disp32 -13936 # save function name -13937 (slice-to-string Heap %ecx %edi) # Function-name -13938 # save function inouts -13939 { -13940 $populate-mu-function-header:check-for-inout: -13941 (next-mu-token *(ebp+8) %ecx) -13942 # if slice-empty?(word-slice) abort -13943 (slice-empty? %ecx) # => eax -13944 3d/compare-eax-and 0/imm32/false -13945 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 -13946 # if (word-slice == '{') goto done -13947 (slice-equal? %ecx "{") # => eax -13948 3d/compare-eax-and 0/imm32/false -13949 0f 85/jump-if-!= $populate-mu-function-header:done/disp32 -13950 # if (word-slice == '->') break -13951 (slice-equal? %ecx "->") # => eax -13952 3d/compare-eax-and 0/imm32/false -13953 0f 85/jump-if-!= break/disp32 -13954 # if (word-slice == '}') abort -13955 (slice-equal? %ecx "}") # => eax -13956 3d/compare-eax-and 0/imm32/false -13957 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 -13958 # v = parse-var-with-type(word-slice, first-line) -13959 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x14) *(ebp+0x18)) -13960 # assert(v->register == null) -13961 # . eax: (addr var) = lookup(v) -13962 (lookup *ebx *(ebx+4)) # => eax -13963 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register -13964 0f 85/jump-if-!= $populate-mu-function-header:error2/disp32 -13965 # v->block-depth is implicitly 0 -13966 # -13967 # out->inouts = append(v, out->inouts) -13968 8d/copy-address *(edi+8) 0/r32/eax # Function-inouts -13969 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax) # Function-inouts, Function-inouts -13970 # push(vars, {v, false}) -13971 (push *(ebp+0x10) *ebx) -13972 (push *(ebp+0x10) *(ebx+4)) -13973 (push *(ebp+0x10) 0) # false -13974 # -13975 e9/jump loop/disp32 -13976 } -13977 # save function outputs -13978 { -13979 $populate-mu-function-header:check-for-out: -13980 (next-mu-token *(ebp+8) %ecx) -13981 # if slice-empty?(word-slice) abort -13982 (slice-empty? %ecx) # => eax -13983 3d/compare-eax-and 0/imm32/false -13984 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 -13985 # if (word-slice == '{') break -13986 (slice-equal? %ecx "{") # => eax -13987 3d/compare-eax-and 0/imm32/false -13988 0f 85/jump-if-!= break/disp32 -13989 # if (word-slice == '->') abort -13990 (slice-equal? %ecx "->") # => eax -13991 3d/compare-eax-and 0/imm32/false -13992 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 -13993 # if (word-slice == '}') abort -13994 (slice-equal? %ecx "}") # => eax -13995 3d/compare-eax-and 0/imm32/false -13996 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 -13997 # v = parse-var-with-type(word-slice, first-line) -13998 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x14) *(ebp+0x18)) -13999 # assert(var->register != null) -14000 # . eax: (addr var) = lookup(v) -14001 (lookup *ebx *(ebx+4)) # => eax -14002 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register -14003 0f 84/jump-if-= $populate-mu-function-header:error3/disp32 -14004 # assert(var->name == "_") -14005 (lookup *eax *(eax+4)) # Var-name Var-name => eax -14006 (string-equal? %eax "_") # => eax -14007 3d/compare-eax-and 0/imm32/false -14008 0f 84/jump-if-= $populate-mu-function-header:error4/disp32 -14009 # out->outputs = append(v, out->outputs) -14010 8d/copy-address *(edi+0x10) 0/r32/eax # Function-outputs -14011 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax) # Function-outputs, Function-outputs -14012 # -14013 e9/jump loop/disp32 -14014 } -14015 $populate-mu-function-header:done: -14016 (check-no-tokens-left *(ebp+8)) -14017 $populate-mu-function-header:end: -14018 # . reclaim locals -14019 81 0/subop/add %esp 0x10/imm32 -14020 # . restore registers -14021 5f/pop-to-edi -14022 5b/pop-to-ebx -14023 5a/pop-to-edx -14024 59/pop-to-ecx -14025 58/pop-to-eax -14026 # . epilogue -14027 89/<- %esp 5/r32/ebp -14028 5d/pop-to-ebp -14029 c3/return -14030 -14031 $populate-mu-function-header:error1: -14032 # error("function header not in form 'fn <name> {'") -14033 (write-buffered *(ebp+0x14) "function header not in form 'fn <name> [inouts] [-> outputs] {' -- '") -14034 (flush *(ebp+0x14)) -14035 (rewind-stream *(ebp+8)) -14036 (write-stream-data *(ebp+0x14) *(ebp+8)) -14037 (write-buffered *(ebp+0x14) "'\n") -14038 (flush *(ebp+0x14)) -14039 (stop *(ebp+0x18) 1) -14040 # never gets here -14041 -14042 $populate-mu-function-header:error2: -14043 # error("fn " fn ": function inout '" var "' cannot be in a register") -14044 (write-buffered *(ebp+0x14) "fn ") -14045 50/push-eax -14046 (lookup *edi *(edi+4)) # Function-name Function-name => eax -14047 (write-buffered *(ebp+0x14) %eax) -14048 58/pop-to-eax -14049 (write-buffered *(ebp+0x14) ": function inout '") -14050 (lookup *eax *(eax+4)) # Var-name Var-name => eax -14051 (write-buffered *(ebp+0x14) %eax) -14052 (write-buffered *(ebp+0x14) "' cannot be in a register") -14053 (flush *(ebp+0x14)) -14054 (stop *(ebp+0x18) 1) -14055 # never gets here -14056 -14057 $populate-mu-function-header:error3: -14058 # error("fn " fn ": function output '" var "' must be in a register") -14059 (write-buffered *(ebp+0x14) "fn ") -14060 50/push-eax -14061 (lookup *edi *(edi+4)) # Function-name Function-name => eax -14062 (write-buffered *(ebp+0x14) %eax) -14063 58/pop-to-eax -14064 (write-buffered *(ebp+0x14) ": function output '") -14065 (lookup *ebx *(ebx+4)) # => eax -14066 (lookup *eax *(eax+4)) # Var-name Var-name => eax -14067 (write-buffered *(ebp+0x14) %eax) -14068 (write-buffered *(ebp+0x14) "' must be in a register, in instruction '") -14069 (rewind-stream *(ebp+8)) -14070 (write-stream-data *(ebp+0x14) *(ebp+8)) -14071 (write-buffered *(ebp+0x14) "'\n") -14072 (flush *(ebp+0x14)) -14073 (stop *(ebp+0x18) 1) -14074 # never gets here -14075 -14076 $populate-mu-function-header:error4: -14077 # error("fn " fn ": function outputs cannot be named; rename '" var "' in the header to '_'") -14078 (write-buffered *(ebp+0x14) "fn ") -14079 50/push-eax -14080 (lookup *edi *(edi+4)) # Function-name Function-name => eax -14081 (write-buffered *(ebp+0x14) %eax) -14082 58/pop-to-eax -14083 (write-buffered *(ebp+0x14) ": function outputs cannot be named; rename '") -14084 (lookup *ebx *(ebx+4)) # => eax -14085 (lookup *eax *(eax+4)) # Var-name Var-name => eax -14086 (write-buffered *(ebp+0x14) %eax) -14087 (write-buffered *(ebp+0x14) "' in the header to '_'\n") -14088 (flush *(ebp+0x14)) -14089 (stop *(ebp+0x18) 1) -14090 # never gets here -14091 -14092 $populate-mu-function-header:error-duplicate: -14093 (write-buffered *(ebp+0x14) "fn ") -14094 (write-slice-buffered *(ebp+0x14) %ecx) -14095 (write-buffered *(ebp+0x14) " defined more than once\n") -14096 (flush *(ebp+0x14)) -14097 (stop *(ebp+0x18) 1) -14098 # never gets here -14099 -14100 $populate-mu-function-header:error-break: -14101 (write-buffered *(ebp+0x14) "Sorry, I've reserved all function names starting with 'break' for now. Please contact mu@akkartik.com.\n") -14102 (flush *(ebp+0x14)) -14103 (stop *(ebp+0x18) 1) -14104 # never gets here -14105 -14106 $populate-mu-function-header:error-loop: -14107 (write-buffered *(ebp+0x14) "Sorry, I've reserved all function names starting with 'loop' for now. Please contact mu@akkartik.com.\n") -14108 (flush *(ebp+0x14)) -14109 (stop *(ebp+0x18) 1) -14110 # never gets here -14111 -14112 # scenarios considered: -14113 # ✓ fn foo -14114 # ✗ fn foo { -14115 # ✓ fn foo x -14116 # ✓ fn foo x: int -14117 # ✓ fn foo x: int -> _/eax: int -14118 # TODO: -14119 # disallow outputs of type `(... addr ...)` -14120 # disallow inputs of type `(... addr ... addr ...)` -14121 populate-mu-function-signature: # first-line: (addr stream byte), out: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -14122 # pseudocode: -14123 # var word-slice: slice -14124 # next-mu-token(first-line, word-slice) -14125 # assert(word-slice not in '{' '}' '->') -14126 # out->name = slice-to-string(word-slice) -14127 # ## inouts -14128 # while true -14129 # word-slice = next-mu-token(first-line) -14130 # if slice-empty?(word-slice) break -14131 # if (word-slice == '->') break -14132 # assert(word-slice not in '{' '}') -14133 # var v: (handle var) = parse-var-with-type(word-slice, first-line) -14134 # assert(v->register == null) -14135 # # v->block-depth is implicitly 0 -14136 # out->inouts = append(v, out->inouts) -14137 # ## outputs -14138 # while true -14139 # word-slice = next-mu-token(first-line) -14140 # if slice-empty?(word-slice) break -14141 # assert(word-slice not in '{' '}' '->') -14142 # var v: (handle var) = parse-var-with-type(word-slice, first-line) -14143 # assert(v->register != null) -14144 # out->outputs = append(v, out->outputs) -14145 # -14146 # . prologue -14147 55/push-ebp -14148 89/<- %ebp 4/r32/esp -14149 # . save registers -14150 50/push-eax -14151 51/push-ecx -14152 52/push-edx -14153 53/push-ebx -14154 57/push-edi -14155 # edi = out -14156 8b/-> *(ebp+0xc) 7/r32/edi -14157 # var word-slice/ecx: slice -14158 68/push 0/imm32/end -14159 68/push 0/imm32/start -14160 89/<- %ecx 4/r32/esp -14161 # var v/ebx: (handle var) -14162 68/push 0/imm32 -14163 68/push 0/imm32 -14164 89/<- %ebx 4/r32/esp -14165 # read function name -14166 (next-mu-token *(ebp+8) %ecx) -14167 # error checking -14168 # if (word-slice == '{') abort -14169 (slice-equal? %ecx "{") # => eax -14170 3d/compare-eax-and 0/imm32/false -14171 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 -14172 # if (word-slice == '->') abort -14173 (slice-equal? %ecx "->") # => eax -14174 3d/compare-eax-and 0/imm32/false -14175 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 -14176 # if (word-slice == '}') abort -14177 (slice-equal? %ecx "}") # => eax -14178 3d/compare-eax-and 0/imm32/false -14179 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 -14180 # if word-slice already defined, abort -14181 (function-exists? %ecx) # => eax -14182 3d/compare-eax-and 0/imm32/false -14183 0f 85/jump-if-!= $populate-mu-function-signature:error-duplicate/disp32 -14184 # -14185 (slice-starts-with? %ecx "break") # => eax -14186 3d/compare-eax-and 0/imm32/false -14187 0f 85/jump-if-!= $populate-mu-function-signature:error-break/disp32 -14188 (slice-starts-with? %ecx "loop") # => eax -14189 3d/compare-eax-and 0/imm32/false -14190 0f 85/jump-if-!= $populate-mu-function-signature:error-loop/disp32 -14191 # save function name -14192 (slice-to-string Heap %ecx %edi) # Function-name -14193 # save function inouts -14194 { -14195 $populate-mu-function-signature:check-for-inout: -14196 (next-mu-token *(ebp+8) %ecx) -14197 (slice-empty? %ecx) # => eax -14198 3d/compare-eax-and 0/imm32/false -14199 0f 85/jump-if-!= break/disp32 -14200 # if (word-slice == '->') break -14201 (slice-equal? %ecx "->") # => eax -14202 3d/compare-eax-and 0/imm32/false -14203 0f 85/jump-if-!= break/disp32 -14204 # if (word-slice == '{') abort -14205 (slice-equal? %ecx "{") # => eax -14206 3d/compare-eax-and 0/imm32/false -14207 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 -14208 # if (word-slice == '}') abort -14209 (slice-equal? %ecx "}") # => eax -14210 3d/compare-eax-and 0/imm32/false -14211 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 -14212 # v = parse-var-with-type(word-slice, first-line) -14213 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x10) *(ebp+0x14)) -14214 # assert(v->register == null) -14215 # . eax: (addr var) = lookup(v) -14216 (lookup *ebx *(ebx+4)) # => eax -14217 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register -14218 0f 85/jump-if-!= $populate-mu-function-signature:error2/disp32 -14219 # v->block-depth is implicitly 0 -14220 # -14221 # out->inouts = append(v, out->inouts) -14222 8d/copy-address *(edi+8) 0/r32/eax # Function-inouts -14223 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax) # Function-inouts, Function-inouts -14224 # -14225 e9/jump loop/disp32 -14226 } -14227 # save function outputs -14228 { -14229 $populate-mu-function-signature:check-for-out: -14230 (next-mu-token *(ebp+8) %ecx) -14231 (slice-empty? %ecx) # => eax -14232 3d/compare-eax-and 0/imm32/false -14233 0f 85/jump-if-!= break/disp32 -14234 # if (word-slice == '{') abort -14235 (slice-equal? %ecx "{") # => eax -14236 3d/compare-eax-and 0/imm32/false -14237 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 -14238 # if (word-slice == '->') abort -14239 (slice-equal? %ecx "->") # => eax -14240 3d/compare-eax-and 0/imm32/false -14241 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 -14242 # if (word-slice == '}') abort -14243 (slice-equal? %ecx "}") # => eax -14244 3d/compare-eax-and 0/imm32/false -14245 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 -14246 # v = parse-var-with-type(word-slice, first-line) -14247 (parse-var-with-type %ecx *(ebp+8) %ebx *(ebp+0x10) *(ebp+0x14)) -14248 # assert(var->register != null) -14249 # . eax: (addr var) = lookup(v) -14250 (lookup *ebx *(ebx+4)) # => eax -14251 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register -14252 0f 84/jump-if-= $populate-mu-function-signature:error3/disp32 -14253 # out->outputs = append(v, out->outputs) -14254 8d/copy-address *(edi+0x10) 0/r32/eax # Function-outputs -14255 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax) # Function-outputs, Function-outputs -14256 # -14257 e9/jump loop/disp32 -14258 } -14259 $populate-mu-function-signature:done: -14260 (check-no-tokens-left *(ebp+8)) -14261 $populate-mu-function-signature:end: -14262 # . reclaim locals -14263 81 0/subop/add %esp 0x10/imm32 -14264 # . restore registers -14265 5f/pop-to-edi -14266 5b/pop-to-ebx -14267 5a/pop-to-edx -14268 59/pop-to-ecx -14269 58/pop-to-eax -14270 # . epilogue -14271 89/<- %esp 5/r32/ebp -14272 5d/pop-to-ebp -14273 c3/return -14274 -14275 $populate-mu-function-signature:error1: -14276 # error("function signature not in form 'fn <name> {'") -14277 (write-buffered *(ebp+0x10) "function signature not in form 'fn <name> [inouts] [-> outputs] {' -- '") -14278 (flush *(ebp+0x10)) -14279 (rewind-stream *(ebp+8)) -14280 (write-stream-data *(ebp+0x10) *(ebp+8)) -14281 (write-buffered *(ebp+0x10) "'\n") -14282 (flush *(ebp+0x10)) -14283 (stop *(ebp+0x14) 1) -14284 # never gets here -14285 -14286 $populate-mu-function-signature:error2: -14287 # error("fn " fn ": function inout '" var "' cannot be in a register") -14288 (write-buffered *(ebp+0x10) "fn ") -14289 50/push-eax -14290 (lookup *edi *(edi+4)) # Function-name Function-name => eax -14291 (write-buffered *(ebp+0x10) %eax) -14292 58/pop-to-eax -14293 (write-buffered *(ebp+0x10) ": function inout '") -14294 (lookup *eax *(eax+4)) # Var-name Var-name => eax -14295 (write-buffered *(ebp+0x10) %eax) -14296 (write-buffered *(ebp+0x10) "' cannot be in a register") -14297 (flush *(ebp+0x10)) -14298 (stop *(ebp+0x14) 1) -14299 # never gets here -14300 -14301 $populate-mu-function-signature:error3: -14302 # error("fn " fn ": function output '" var "' must be in a register") -14303 (write-buffered *(ebp+0x10) "fn ") -14304 50/push-eax -14305 (lookup *edi *(edi+4)) # Function-name Function-name => eax -14306 (write-buffered *(ebp+0x10) %eax) -14307 58/pop-to-eax -14308 (write-buffered *(ebp+0x10) ": function output '") -14309 (lookup *ebx *(ebx+4)) # => eax -14310 (lookup *eax *(eax+4)) # Var-name Var-name => eax -14311 (write-buffered *(ebp+0x10) %eax) -14312 (write-buffered *(ebp+0x10) "' must be in a register, in instruction '") -14313 (rewind-stream *(ebp+8)) -14314 (write-stream-data *(ebp+0x10) *(ebp+8)) -14315 (write-buffered *(ebp+0x10) "'\n") -14316 (flush *(ebp+0x10)) -14317 (stop *(ebp+0x14) 1) -14318 # never gets here -14319 -14320 $populate-mu-function-signature:error-duplicate: -14321 (write-buffered *(ebp+0x10) "fn ") -14322 (write-slice-buffered *(ebp+0x10) %ecx) -14323 (write-buffered *(ebp+0x10) " defined more than once\n") -14324 (flush *(ebp+0x10)) -14325 (stop *(ebp+0x14) 1) -14326 # never gets here -14327 -14328 $populate-mu-function-signature:error-break: -14329 (write-buffered *(ebp+0x14) "Sorry, I've reserved all function names starting with 'break' for now. Please contact mu@akkartik.com.\n") -14330 (flush *(ebp+0x14)) -14331 (stop *(ebp+0x18) 1) -14332 # never gets here -14333 -14334 $populate-mu-function-signature:error-loop: -14335 (write-buffered *(ebp+0x14) "Sorry, I've reserved all function names starting with 'loop' for now. Please contact mu@akkartik.com.\n") -14336 (flush *(ebp+0x14)) -14337 (stop *(ebp+0x18) 1) -14338 # never gets here -14339 -14340 function-exists?: # s: (addr slice) -> result/eax: boolean -14341 # . prologue -14342 55/push-ebp -14343 89/<- %ebp 4/r32/esp -14344 # . save registers -14345 51/push-ecx -14346 # var curr/ecx: (addr function) = functions -14347 (lookup *_Program-functions *_Program-functions->payload) # => eax -14348 89/<- %ecx 0/r32/eax -14349 { -14350 # if (curr == null) break -14351 81 7/subop/compare %ecx 0/imm32 -14352 74/jump-if-= break/disp8 -14353 # if (curr->name == s) return true -14354 { -14355 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax -14356 (slice-equal? *(ebp+8) %eax) # => eax -14357 3d/compare-eax-and 0/imm32/false -14358 74/jump-if-= break/disp8 -14359 b8/copy-to-eax 1/imm32/true -14360 e9/jump $function-exists?:end/disp32 -14361 } -14362 # curr = curr->next -14363 (lookup *(ecx+0x20) *(ecx+0x24)) # Function-next Function-next => eax -14364 89/<- %ecx 0/r32/eax -14365 # -14366 eb/jump loop/disp8 -14367 } -14368 # var curr/ecx: (addr function) = signatures -14369 (lookup *_Program-signatures *_Program-signatures->payload) # => eax -14370 89/<- %ecx 0/r32/eax -14371 { -14372 # if (curr == null) break -14373 81 7/subop/compare %ecx 0/imm32 -14374 74/jump-if-= break/disp8 -14375 # if (curr->name == s) return true -14376 { -14377 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax -14378 (slice-equal? *(ebp+8) %eax) # => eax -14379 3d/compare-eax-and 0/imm32/false -14380 74/jump-if-= break/disp8 -14381 b8/copy-to-eax 1/imm32/true -14382 eb/jump $function-exists?:end/disp8 -14383 } -14384 # curr = curr->next -14385 (lookup *(ecx+0x20) *(ecx+0x24)) # Function-next Function-next => eax -14386 89/<- %ecx 0/r32/eax -14387 # -14388 eb/jump loop/disp8 -14389 } -14390 # return false -14391 b8/copy-to-eax 0/imm32/false -14392 $function-exists?:end: -14393 # . restore registers -14394 59/pop-to-ecx -14395 # . epilogue -14396 89/<- %esp 5/r32/ebp -14397 5d/pop-to-ebp -14398 c3/return +13832 test-populate-deref-address: +13833 # . prologue +13834 55/push-ebp +13835 89/<- %ebp 4/r32/esp +13836 # setup +13837 (clear-stream _test-input-stream) +13838 (clear-stream $_test-input-buffered-file->buffer) +13839 (clear-stream _test-output-stream) +13840 (clear-stream $_test-output-buffered-file->buffer) +13841 # +13842 (write _test-input-stream "fn foo {\n") +13843 (write _test-input-stream " var y/ecx: (addr addr handle array int) <- copy 0\n") +13844 (write _test-input-stream " populate *y, 3\n") +13845 (write _test-input-stream "}\n") +13846 # convert +13847 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +13848 (flush _test-output-buffered-file) +13849 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13855 # not bothering checking output +13856 (check-next-stream-line-equal _test-error-stream "" "F - test-populate-deref-address: error message") +13857 # . epilogue +13858 5d/pop-to-ebp +13859 c3/return +13860 +13861 test-populate-stream-with-no-inout: +13862 # . prologue +13863 55/push-ebp +13864 89/<- %ebp 4/r32/esp +13865 # setup +13866 (clear-stream _test-input-stream) +13867 (clear-stream $_test-input-buffered-file->buffer) +13868 (clear-stream _test-output-stream) +13869 (clear-stream $_test-output-buffered-file->buffer) +13870 (clear-stream _test-error-stream) +13871 (clear-stream $_test-error-buffered-file->buffer) +13872 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13873 68/push 0/imm32 +13874 68/push 0/imm32 +13875 89/<- %edx 4/r32/esp +13876 (tailor-exit-descriptor %edx 0x10) +13877 # +13878 (write _test-input-stream "fn foo {\n") +13879 (write _test-input-stream " populate-stream\n") +13880 (write _test-input-stream "}\n") +13881 # convert +13882 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13883 # registers except esp clobbered at this point +13884 # restore ed +13885 89/<- %edx 4/r32/esp +13886 (flush _test-output-buffered-file) +13887 (flush _test-error-buffered-file) +13888 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13894 # check output +13895 (check-stream-equal _test-output-stream "" "F - test-populate-stream-with-no-inout: output should be empty") +13896 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate-stream' must have two inouts" "F - test-populate-stream-with-no-inout: error message") +13897 # check that stop(1) was called +13898 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-with-no-inout: exit status") +13899 # don't restore from ebp +13900 81 0/subop/add %esp 8/imm32 +13901 # . epilogue +13902 5d/pop-to-ebp +13903 c3/return +13904 +13905 test-populate-stream-with-too-many-inouts: +13906 # . prologue +13907 55/push-ebp +13908 89/<- %ebp 4/r32/esp +13909 # setup +13910 (clear-stream _test-input-stream) +13911 (clear-stream $_test-input-buffered-file->buffer) +13912 (clear-stream _test-output-stream) +13913 (clear-stream $_test-output-buffered-file->buffer) +13914 (clear-stream _test-error-stream) +13915 (clear-stream $_test-error-buffered-file->buffer) +13916 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13917 68/push 0/imm32 +13918 68/push 0/imm32 +13919 89/<- %edx 4/r32/esp +13920 (tailor-exit-descriptor %edx 0x10) +13921 # +13922 (write _test-input-stream "fn foo {\n") +13923 (write _test-input-stream " var x: (addr handle int)\n") +13924 (write _test-input-stream " populate-stream x, 3, 0\n") +13925 (write _test-input-stream "}\n") +13926 # convert +13927 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13928 # registers except esp clobbered at this point +13929 # restore ed +13930 89/<- %edx 4/r32/esp +13931 (flush _test-output-buffered-file) +13932 (flush _test-error-buffered-file) +13933 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13939 # check output +13940 (check-stream-equal _test-output-stream "" "F - test-populate-stream-with-too-many-inouts: output should be empty") +13941 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate-stream' must have two inouts" "F - test-populate-stream-with-too-many-inouts: error message") +13942 # check that stop(1) was called +13943 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-with-too-many-inouts: exit status") +13944 # don't restore from ebp +13945 81 0/subop/add %esp 8/imm32 +13946 # . epilogue +13947 5d/pop-to-ebp +13948 c3/return +13949 +13950 test-populate-stream-with-output: +13951 # . prologue +13952 55/push-ebp +13953 89/<- %ebp 4/r32/esp +13954 # setup +13955 (clear-stream _test-input-stream) +13956 (clear-stream $_test-input-buffered-file->buffer) +13957 (clear-stream _test-output-stream) +13958 (clear-stream $_test-output-buffered-file->buffer) +13959 (clear-stream _test-error-stream) +13960 (clear-stream $_test-error-buffered-file->buffer) +13961 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +13962 68/push 0/imm32 +13963 68/push 0/imm32 +13964 89/<- %edx 4/r32/esp +13965 (tailor-exit-descriptor %edx 0x10) +13966 # +13967 (write _test-input-stream "fn foo {\n") +13968 (write _test-input-stream " var x/eax: boolean <- copy 0\n") +13969 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") +13970 (write _test-input-stream " x <- populate-stream y\n") +13971 (write _test-input-stream "}\n") +13972 # convert +13973 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +13974 # registers except esp clobbered at this point +13975 # restore ed +13976 89/<- %edx 4/r32/esp +13977 (flush _test-output-buffered-file) +13978 (flush _test-error-buffered-file) +13979 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +13985 # check output +13986 (check-stream-equal _test-output-stream "" "F - test-populate-stream-with-output: output should be empty") +13987 (check-next-stream-line-equal _test-error-stream "fn foo: stmt 'populate-stream' must not have any outputs" "F - test-populate-stream-with-output: error message") +13988 # check that stop(1) was called +13989 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-with-output: exit status") +13990 # don't restore from ebp +13991 81 0/subop/add %esp 8/imm32 +13992 # . epilogue +13993 5d/pop-to-ebp +13994 c3/return +13995 +13996 test-populate-stream-non-addr: +13997 # . prologue +13998 55/push-ebp +13999 89/<- %ebp 4/r32/esp +14000 # setup +14001 (clear-stream _test-input-stream) +14002 (clear-stream $_test-input-buffered-file->buffer) +14003 (clear-stream _test-output-stream) +14004 (clear-stream $_test-output-buffered-file->buffer) +14005 (clear-stream _test-error-stream) +14006 (clear-stream $_test-error-buffered-file->buffer) +14007 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +14008 68/push 0/imm32 +14009 68/push 0/imm32 +14010 89/<- %edx 4/r32/esp +14011 (tailor-exit-descriptor %edx 0x10) +14012 # +14013 (write _test-input-stream "fn foo {\n") +14014 (write _test-input-stream " var y: (handle int)\n") +14015 (write _test-input-stream " populate-stream y, 3\n") +14016 (write _test-input-stream "}\n") +14017 # convert +14018 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +14019 # registers except esp clobbered at this point +14020 # restore ed +14021 89/<- %edx 4/r32/esp +14022 (flush _test-output-buffered-file) +14023 (flush _test-error-buffered-file) +14024 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14030 # check output +14031 (check-stream-equal _test-output-stream "" "F - test-populate-stream-non-addr: output must be empty") +14032 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate-stream: first inout 'y' must have type (addr handle stream ...)" "F - test-populate-stream-non-addr: error message") +14033 # check that stop(1) was called +14034 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-non-addr: exit status") +14035 # don't restore from ebp +14036 81 0/subop/add %esp 8/imm32 +14037 # . epilogue +14038 5d/pop-to-ebp +14039 c3/return +14040 +14041 test-populate-stream-non-addr-handle: +14042 # . prologue +14043 55/push-ebp +14044 89/<- %ebp 4/r32/esp +14045 # setup +14046 (clear-stream _test-input-stream) +14047 (clear-stream $_test-input-buffered-file->buffer) +14048 (clear-stream _test-output-stream) +14049 (clear-stream $_test-output-buffered-file->buffer) +14050 (clear-stream _test-error-stream) +14051 (clear-stream $_test-error-buffered-file->buffer) +14052 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +14053 68/push 0/imm32 +14054 68/push 0/imm32 +14055 89/<- %edx 4/r32/esp +14056 (tailor-exit-descriptor %edx 0x10) +14057 # +14058 (write _test-input-stream "fn foo {\n") +14059 (write _test-input-stream " var y/ecx: (addr int) <- copy 0\n") +14060 (write _test-input-stream " populate-stream y, 3\n") +14061 (write _test-input-stream "}\n") +14062 # convert +14063 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +14064 # registers except esp clobbered at this point +14065 # restore ed +14066 89/<- %edx 4/r32/esp +14067 (flush _test-output-buffered-file) +14068 (flush _test-error-buffered-file) +14069 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14075 # check output +14076 (check-stream-equal _test-output-stream "" "F - test-populate-stream-non-addr-handle: output should be empty") +14077 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate-stream: first inout 'y' must have type (addr handle stream ...)" "F - test-populate-stream-non-addr-handle: error message") +14078 # check that stop(1) was called +14079 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-non-addr-handle: exit status") +14080 # don't restore from ebp +14081 81 0/subop/add %esp 8/imm32 +14082 # . epilogue +14083 5d/pop-to-ebp +14084 c3/return +14085 +14086 test-populate-stream-non-addr-handle-stream: +14087 # . prologue +14088 55/push-ebp +14089 89/<- %ebp 4/r32/esp +14090 # setup +14091 (clear-stream _test-input-stream) +14092 (clear-stream $_test-input-buffered-file->buffer) +14093 (clear-stream _test-output-stream) +14094 (clear-stream $_test-output-buffered-file->buffer) +14095 (clear-stream _test-error-stream) +14096 (clear-stream $_test-error-buffered-file->buffer) +14097 # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) +14098 68/push 0/imm32 +14099 68/push 0/imm32 +14100 89/<- %edx 4/r32/esp +14101 (tailor-exit-descriptor %edx 0x10) +14102 # +14103 (write _test-input-stream "fn foo {\n") +14104 (write _test-input-stream " var y/ecx: (addr handle int) <- copy 0\n") +14105 (write _test-input-stream " populate-stream y, 3\n") +14106 (write _test-input-stream "}\n") +14107 # convert +14108 (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) +14109 # registers except esp clobbered at this point +14110 # restore ed +14111 89/<- %edx 4/r32/esp +14112 (flush _test-output-buffered-file) +14113 (flush _test-error-buffered-file) +14114 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14120 # check output +14121 (check-stream-equal _test-output-stream "" "F - test-populate-stream-non-addr-handle-stream: output should be empty") +14122 (check-next-stream-line-equal _test-error-stream "fn foo: stmt populate-stream: first inout 'y' must have type (addr handle stream ...)" "F - test-populate-stream-non-addr-handle-stream: error message") +14123 # check that stop(1) was called +14124 (check-ints-equal *(edx+4) 2 "F - test-populate-stream-non-addr-handle-stream: exit status") +14125 # don't restore from ebp +14126 81 0/subop/add %esp 8/imm32 +14127 # . epilogue +14128 5d/pop-to-ebp +14129 c3/return +14130 +14131 test-populate-stream-deref-address: +14132 # . prologue +14133 55/push-ebp +14134 89/<- %ebp 4/r32/esp +14135 # setup +14136 (clear-stream _test-input-stream) +14137 (clear-stream $_test-input-buffered-file->buffer) +14138 (clear-stream _test-output-stream) +14139 (clear-stream $_test-output-buffered-file->buffer) +14140 # +14141 (write _test-input-stream "fn foo {\n") +14142 (write _test-input-stream " var y/ecx: (addr addr handle stream int) <- copy 0\n") +14143 (write _test-input-stream " populate-stream *y, 3\n") +14144 (write _test-input-stream "}\n") +14145 # convert +14146 (convert-mu _test-input-buffered-file _test-output-buffered-file Stderr 0) +14147 (flush _test-output-buffered-file) +14148 +-- 6 lines: #? # dump _test-error-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14154 # not bothering checking output +14155 (check-next-stream-line-equal _test-error-stream "" "F - test-populate-stream-deref-address: error message") +14156 # . epilogue +14157 5d/pop-to-ebp +14158 c3/return +14159 +14160 ####################################################### +14161 # Parsing +14162 ####################################################### +14163 +14164 == data +14165 +14166 # Global state added to each var record when parsing a function +14167 Next-block-index: # (addr int) +14168 1/imm32 +14169 +14170 Curr-block-depth: # (addr int) +14171 1/imm32 +14172 +14173 == code +14174 +14175 parse-mu: # in: (addr buffered-file), err: (addr buffered-file), ed: (addr exit-descriptor) +14176 # pseudocode +14177 # var curr-function: (addr handle function) = Program->functions +14178 # var curr-signature: (addr handle function) = Program->signatures +14179 # var curr-type: (addr handle typeinfo) = Program->types +14180 # var line: (stream byte 512) +14181 # var word-slice: slice +14182 # while true # line loop +14183 # clear-stream(line) +14184 # read-line-buffered(in, line) +14185 # if (line->write == 0) break # end of file +14186 # word-slice = next-mu-token(line) +14187 # if slice-empty?(word-slice) # end of line +14188 # continue +14189 # else if slice-starts-with?(word-slice, "#") # comment +14190 # continue # end of line +14191 # else if slice-equal?(word-slice, "fn") +14192 # var new-function: (handle function) = allocate(function) +14193 # var vars: (stack live-var 256) +14194 # populate-mu-function-header(line, new-function, vars) +14195 # populate-mu-function-body(in, new-function, vars) +14196 # assert(vars->top == 0) +14197 # *curr-function = new-function +14198 # curr-function = &new-function->next +14199 # else if slice-equal?(word-slice, "sig") +14200 # var new-function: (handle function) = allocate(function) +14201 # populate-mu-function-signature(line, new-function) +14202 # *curr-signature = new-function +14203 # curr-signature = &new-function->next +14204 # else if slice-equal?(word-slice, "type") +14205 # word-slice = next-mu-token(line) +14206 # type-id = pos-or-insert-slice(Type-id, word-slice) +14207 # var new-type: (handle typeinfo) = find-or-create-typeinfo(type-id) +14208 # assert(next-word(line) == "{") +14209 # populate-mu-type(in, new-type) +14210 # else +14211 # abort() +14212 # +14213 # . prologue +14214 55/push-ebp +14215 89/<- %ebp 4/r32/esp +14216 # var curr-signature: (addr handle function) at *(ebp-4) +14217 68/push _Program-signatures/imm32 +14218 # . save registers +14219 50/push-eax +14220 51/push-ecx +14221 52/push-edx +14222 53/push-ebx +14223 56/push-esi +14224 57/push-edi +14225 # var line/ecx: (stream byte 512) +14226 81 5/subop/subtract %esp 0x200/imm32 +14227 68/push 0x200/imm32/size +14228 68/push 0/imm32/read +14229 68/push 0/imm32/write +14230 89/<- %ecx 4/r32/esp +14231 # var word-slice/edx: slice +14232 68/push 0/imm32/end +14233 68/push 0/imm32/start +14234 89/<- %edx 4/r32/esp +14235 # var curr-function/edi: (addr handle function) +14236 bf/copy-to-edi _Program-functions/imm32 +14237 # var vars/ebx: (stack live-var 256) +14238 81 5/subop/subtract %esp 0xc00/imm32 +14239 68/push 0xc00/imm32/size +14240 68/push 0/imm32/top +14241 89/<- %ebx 4/r32/esp +14242 { +14243 $parse-mu:line-loop: +14244 (clear-stream %ecx) +14245 (read-line-buffered *(ebp+8) %ecx) +14246 # if (line->write == 0) break +14247 81 7/subop/compare *ecx 0/imm32 +14248 0f 84/jump-if-= break/disp32 +14249 +-- 6 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +14255 (next-mu-token %ecx %edx) +14256 # if slice-empty?(word-slice) continue +14257 (slice-empty? %edx) # => eax +14258 3d/compare-eax-and 0/imm32/false +14259 0f 85/jump-if-!= loop/disp32 +14260 # if (*word-slice->start == "#") continue +14261 # . eax = *word-slice->start +14262 8b/-> *edx 0/r32/eax +14263 8a/copy-byte *eax 0/r32/AL +14264 81 4/subop/and %eax 0xff/imm32 +14265 # . if (eax == '#') continue +14266 3d/compare-eax-and 0x23/imm32/hash +14267 0f 84/jump-if-= loop/disp32 +14268 # if (slice-equal?(word-slice, "fn")) parse a function +14269 { +14270 $parse-mu:fn: +14271 (slice-equal? %edx "fn") # => eax +14272 3d/compare-eax-and 0/imm32/false +14273 0f 84/jump-if-= break/disp32 +14274 # var new-function/esi: (handle function) +14275 68/push 0/imm32 +14276 68/push 0/imm32 +14277 89/<- %esi 4/r32/esp +14278 # populate-mu-function(line, in, vars, new-function) +14279 (allocate Heap *Function-size %esi) +14280 # var new-function-addr/eax: (addr function) +14281 (lookup *esi *(esi+4)) # => eax +14282 # initialize vars +14283 (clear-stack %ebx) +14284 # +14285 (populate-mu-function-header %ecx %eax %ebx *(ebp+0xc) *(ebp+0x10)) +14286 (populate-mu-function-body *(ebp+8) %eax %ebx *(ebp+0xc) *(ebp+0x10)) +14287 # *curr-function = new-function +14288 8b/-> *esi 0/r32/eax +14289 89/<- *edi 0/r32/eax +14290 8b/-> *(esi+4) 0/r32/eax +14291 89/<- *(edi+4) 0/r32/eax +14292 # curr-function = &new-function->next +14293 # . var tmp/eax: (addr function) = lookup(new-function) +14294 (lookup *esi *(esi+4)) # => eax +14295 # . curr-function = &tmp->next +14296 8d/copy-address *(eax+0x20) 7/r32/edi # Function-next +14297 # reclaim new-function +14298 81 0/subop/add %esp 8/imm32 +14299 # +14300 e9/jump $parse-mu:line-loop/disp32 +14301 } +14302 # if (slice-equal?(word-slice, "sig")) parse a function signature +14303 # Function signatures are for providing types to SubX functions. +14304 { +14305 $parse-mu:sig: +14306 (slice-equal? %edx "sig") # => eax +14307 3d/compare-eax-and 0/imm32/false +14308 0f 84/jump-if-= break/disp32 +14309 # edi = curr-function +14310 57/push-edi +14311 8b/-> *(ebp-4) 7/r32/edi +14312 # var new-function/esi: (handle function) +14313 68/push 0/imm32 +14314 68/push 0/imm32 +14315 89/<- %esi 4/r32/esp +14316 # populate-mu-function(line, in, vars, new-function) +14317 (allocate Heap *Function-size %esi) +14318 # var new-function-addr/eax: (addr function) +14319 (lookup *esi *(esi+4)) # => eax +14320 # +14321 (populate-mu-function-signature %ecx %eax *(ebp+0xc) *(ebp+0x10)) +14322 # *curr-signature = new-function +14323 8b/-> *esi 0/r32/eax +14324 89/<- *edi 0/r32/eax +14325 8b/-> *(esi+4) 0/r32/eax +14326 89/<- *(edi+4) 0/r32/eax +14327 # curr-signature = &new-function->next +14328 # . var tmp/eax: (addr function) = lookup(new-function) +14329 (lookup *esi *(esi+4)) # => eax +14330 # . curr-function = &tmp->next +14331 8d/copy-address *(eax+0x20) 7/r32/edi # Function-next +14332 # reclaim new-function +14333 81 0/subop/add %esp 8/imm32 +14334 # save curr-function +14335 89/<- *(ebp-4) 7/r32/edi +14336 # restore edi +14337 5f/pop-to-edi +14338 # +14339 e9/jump $parse-mu:line-loop/disp32 +14340 } +14341 # if (slice-equal?(word-slice, "type")) parse a type (struct/record) definition +14342 { +14343 $parse-mu:type: +14344 (slice-equal? %edx "type") # => eax +14345 3d/compare-eax-and 0/imm32 +14346 0f 84/jump-if-= break/disp32 +14347 (next-mu-token %ecx %edx) +14348 # var type-id/eax: int +14349 (pos-or-insert-slice Type-id %edx) # => eax +14350 # spill +14351 51/push-ecx +14352 # var new-type/ecx: (handle typeinfo) +14353 68/push 0/imm32 +14354 68/push 0/imm32 +14355 89/<- %ecx 4/r32/esp +14356 (find-or-create-typeinfo %eax %ecx) +14357 # +14358 (lookup *ecx *(ecx+4)) # => eax +14359 # TODO: ensure that 'line' has nothing else but '{' +14360 #? (dump-typeinfos "=== aaa\n") +14361 (populate-mu-type *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10)) # => eax +14362 #? (dump-typeinfos "=== zzz\n") +14363 # reclaim new-type +14364 81 0/subop/add %esp 8/imm32 +14365 # restore +14366 59/pop-to-ecx +14367 e9/jump $parse-mu:line-loop/disp32 +14368 } +14369 # otherwise abort +14370 e9/jump $parse-mu:error1/disp32 +14371 } # end line loop +14372 $parse-mu:end: +14373 # . reclaim locals +14374 81 0/subop/add %esp 0x20c/imm32 # line +14375 81 0/subop/add %esp 0xc08/imm32 # vars +14376 81 0/subop/add %esp 8/imm32 +14377 # . restore registers +14378 5f/pop-to-edi +14379 5e/pop-to-esi +14380 5b/pop-to-ebx +14381 5a/pop-to-edx +14382 59/pop-to-ecx +14383 58/pop-to-eax +14384 # . reclaim local +14385 81 0/subop/add %esp 4/imm32 +14386 # . epilogue +14387 89/<- %esp 5/r32/ebp +14388 5d/pop-to-ebp +14389 c3/return +14390 +14391 $parse-mu:error1: +14392 # error("unexpected top-level command: " word-slice "\n") +14393 (write-buffered *(ebp+0xc) "unexpected top-level command: ") +14394 (write-slice-buffered *(ebp+0xc) %edx) +14395 (write-buffered *(ebp+0xc) "\n") +14396 (flush *(ebp+0xc)) +14397 (stop *(ebp+0x10) 1) +14398 # never gets here 14399 -14400 test-function-header-with-arg: -14401 # . prologue -14402 55/push-ebp -14403 89/<- %ebp 4/r32/esp -14404 # setup -14405 8b/-> *Primitive-type-ids 0/r32/eax -14406 89/<- *Type-id 0/r32/eax # stream-write -14407 c7 0/subop/copy *_Program-functions 0/imm32 -14408 c7 0/subop/copy *_Program-functions->payload 0/imm32 -14409 c7 0/subop/copy *_Program-types 0/imm32 -14410 c7 0/subop/copy *_Program-types->payload 0/imm32 -14411 c7 0/subop/copy *_Program-signatures 0/imm32 -14412 c7 0/subop/copy *_Program-signatures->payload 0/imm32 -14413 (clear-stream _test-input-stream) -14414 (write _test-input-stream "foo n: int {\n") -14415 # var result/ecx: function -14416 2b/subtract *Function-size 4/r32/esp -14417 89/<- %ecx 4/r32/esp -14418 (zero-out %ecx *Function-size) -14419 # var vars/ebx: (stack live-var 16) -14420 81 5/subop/subtract %esp 0xc0/imm32 -14421 68/push 0xc0/imm32/size -14422 68/push 0/imm32/top -14423 89/<- %ebx 4/r32/esp -14424 # convert -14425 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) -14426 # check result->name -14427 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax -14428 (check-strings-equal %eax "foo" "F - test-function-header-with-arg/name") -14429 # var v/edx: (addr var) = result->inouts->value -14430 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax -14431 (lookup *eax *(eax+4)) # List-value List-value => eax -14432 89/<- %edx 0/r32/eax -14433 # check v->name -14434 (lookup *edx *(edx+4)) # Var-name Var-name => eax -14435 (check-strings-equal %eax "n" "F - test-function-header-with-arg/inout:0") -14436 # check v->type -14437 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -14438 (check-ints-equal *eax 1 "F - test-function-header-with-arg/inout:0/type:0") # Type-tree-is-atom -14439 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-arg/inout:0/type:1") # Type-tree-value -14440 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-arg/inout:0/type:2") # Type-tree-right -14441 # . epilogue -14442 89/<- %esp 5/r32/ebp -14443 5d/pop-to-ebp -14444 c3/return -14445 -14446 test-function-header-with-multiple-args: -14447 # . prologue -14448 55/push-ebp -14449 89/<- %ebp 4/r32/esp -14450 # setup -14451 8b/-> *Primitive-type-ids 0/r32/eax -14452 89/<- *Type-id 0/r32/eax # stream-write -14453 c7 0/subop/copy *_Program-functions 0/imm32 -14454 c7 0/subop/copy *_Program-functions->payload 0/imm32 -14455 c7 0/subop/copy *_Program-types 0/imm32 -14456 c7 0/subop/copy *_Program-types->payload 0/imm32 -14457 c7 0/subop/copy *_Program-signatures 0/imm32 -14458 c7 0/subop/copy *_Program-signatures->payload 0/imm32 -14459 (clear-stream _test-input-stream) -14460 (write _test-input-stream "foo a: int, b: int c: int {\n") -14461 # result/ecx: function -14462 2b/subtract *Function-size 4/r32/esp -14463 89/<- %ecx 4/r32/esp -14464 (zero-out %ecx *Function-size) -14465 # var vars/ebx: (stack live-var 16) -14466 81 5/subop/subtract %esp 0xc0/imm32 -14467 68/push 0xc0/imm32/size -14468 68/push 0/imm32/top -14469 89/<- %ebx 4/r32/esp -14470 # convert -14471 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) -14472 # check result->name -14473 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax -14474 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args/name") -14475 # var inouts/edx: (addr list var) = lookup(result->inouts) -14476 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax -14477 89/<- %edx 0/r32/eax -14478 $test-function-header-with-multiple-args:inout0: -14479 # var v/ebx: (addr var) = lookup(inouts->value) -14480 (lookup *edx *(edx+4)) # List-value List-value => eax -14481 89/<- %ebx 0/r32/eax -14482 # check v->name -14483 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -14484 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args/inout:0") # Var-name -14485 # check v->type -14486 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax -14487 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:0/type:0") # Type-tree-is-atom -14488 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:0/type:1") # Type-tree-value -14489 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:0/type:2") # Type-tree-right -14490 $test-function-header-with-multiple-args:inout1: -14491 # inouts = lookup(inouts->next) -14492 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax -14493 89/<- %edx 0/r32/eax -14494 # v = lookup(inouts->value) -14495 (lookup *edx *(edx+4)) # List-value List-value => eax -14496 89/<- %ebx 0/r32/eax -14497 # check v->name -14498 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -14499 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args/inout:1") # Var-name -14500 # check v->type -14501 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax -14502 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:1/type:0") # Type-tree-is-atom -14503 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:1/type:1") # Type-tree-value -14504 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:1/type:2") # Type-tree-right -14505 $test-function-header-with-multiple-args:inout2: -14506 # inouts = lookup(inouts->next) -14507 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax -14508 89/<- %edx 0/r32/eax -14509 # v = lookup(inouts->value) -14510 (lookup *edx *(edx+4)) # List-value List-value => eax -14511 89/<- %ebx 0/r32/eax -14512 # check v->name -14513 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -14514 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args/inout:2") # Var-name -14515 # check v->type -14516 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax -14517 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:2/type:0") # Type-tree-is-atom -14518 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:2/type:1") # Type-tree-value -14519 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:2/type:2") # Type-tree-right -14520 # . epilogue -14521 89/<- %esp 5/r32/ebp -14522 5d/pop-to-ebp -14523 c3/return -14524 -14525 test-function-header-with-multiple-args-and-outputs: -14526 # . prologue -14527 55/push-ebp -14528 89/<- %ebp 4/r32/esp -14529 # setup -14530 8b/-> *Primitive-type-ids 0/r32/eax -14531 89/<- *Type-id 0/r32/eax # stream-write -14532 c7 0/subop/copy *_Program-functions 0/imm32 -14533 c7 0/subop/copy *_Program-functions->payload 0/imm32 -14534 c7 0/subop/copy *_Program-types 0/imm32 -14535 c7 0/subop/copy *_Program-types->payload 0/imm32 -14536 c7 0/subop/copy *_Program-signatures 0/imm32 -14537 c7 0/subop/copy *_Program-signatures->payload 0/imm32 -14538 (clear-stream _test-input-stream) -14539 (write _test-input-stream "foo a: int, b: int, c: int -> _/ecx: int _/edx: int {\n") -14540 # result/ecx: function -14541 2b/subtract *Function-size 4/r32/esp -14542 89/<- %ecx 4/r32/esp -14543 (zero-out %ecx *Function-size) -14544 # var vars/ebx: (stack live-var 16) -14545 81 5/subop/subtract %esp 0xc0/imm32 -14546 68/push 0xc0/imm32/size -14547 68/push 0/imm32/top -14548 89/<- %ebx 4/r32/esp -14549 # convert -14550 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) -14551 # check result->name -14552 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax -14553 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args-and-outputs/name") -14554 # var inouts/edx: (addr list var) = lookup(result->inouts) -14555 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax -14556 89/<- %edx 0/r32/eax -14557 $test-function-header-with-multiple-args-and-outputs:inout0: -14558 # var v/ebx: (addr var) = lookup(inouts->value) -14559 (lookup *edx *(edx+4)) # List-value List-value => eax -14560 89/<- %ebx 0/r32/eax -14561 # check v->name -14562 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -14563 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args-and-outputs/inout:0") -14564 # check v->type -14565 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax -14566 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:0") # Type-tree-is-atom -14567 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:1") # Type-tree-value -14568 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:2") # Type-tree-right -14569 $test-function-header-with-multiple-args-and-outputs:inout1: -14570 # inouts = lookup(inouts->next) -14571 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax -14572 89/<- %edx 0/r32/eax -14573 # v = lookup(inouts->value) -14574 (lookup *edx *(edx+4)) # List-value List-value => eax -14575 89/<- %ebx 0/r32/eax -14576 # check v->name -14577 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -14578 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args-and-outputs/inout:1") -14579 # check v->type -14580 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax -14581 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:0") # Type-tree-is-atom -14582 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:1") # Type-tree-value -14583 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:2") # Type-tree-right -14584 $test-function-header-with-multiple-args-and-outputs:inout2: -14585 # inouts = lookup(inouts->next) -14586 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax -14587 89/<- %edx 0/r32/eax -14588 # v = lookup(inouts->value) -14589 (lookup *edx *(edx+4)) # List-value List-value => eax -14590 89/<- %ebx 0/r32/eax -14591 # check v->name -14592 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -14593 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args-and-outputs/inout:2") -14594 # check v->type -14595 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax -14596 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:0") # Type-tree-is-atom -14597 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:1") # Type-tree-value -14598 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:2") # Type-tree-right -14599 $test-function-header-with-multiple-args-and-outputs:out0: -14600 # var outputs/edx: (addr list var) = lookup(result->outputs) -14601 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax -14602 89/<- %edx 0/r32/eax -14603 # v = lookup(outputs->value) -14604 (lookup *edx *(edx+4)) # List-value List-value => eax -14605 89/<- %ebx 0/r32/eax -14606 # check v->name -14607 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -14608 (check-strings-equal %eax "_" "F - test-function-header-with-multiple-args-and-outputs/output:0") -14609 # check v->register -14610 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -14611 (check-strings-equal %eax "ecx" "F - test-function-header-with-multiple-args-and-outputs/output:0/register") -14612 # check v->type -14613 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax -14614 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:0") # Type-tree-is-atom -14615 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:1") # Type-tree-value -14616 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:2") # Type-tree-right -14617 $test-function-header-with-multiple-args-and-outputs:out1: -14618 # outputs = lookup(outputs->next) -14619 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax -14620 89/<- %edx 0/r32/eax -14621 # v = lookup(inouts->value) -14622 (lookup *edx *(edx+4)) # List-value List-value => eax -14623 89/<- %ebx 0/r32/eax -14624 # check v->name -14625 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -14626 (check-strings-equal %eax "_" "F - test-function-header-with-multiple-args-and-outputs/output:1") -14627 # check v->register -14628 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -14629 (check-strings-equal %eax "edx" "F - test-function-header-with-multiple-args-and-outputs/output:1/register") -14630 # check v->type -14631 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax -14632 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:0") # Type-tree-is-atom -14633 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:1") # Type-tree-value -14634 (check-ints-equal *(eax+0c) 0 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:2") # Type-tree-right -14635 # . epilogue -14636 89/<- %esp 5/r32/ebp -14637 5d/pop-to-ebp -14638 c3/return -14639 -14640 # format for variables with types -14641 # x: int -14642 # x: int, -14643 # x/eax: int -14644 # x/eax: int, -14645 # ignores at most one trailing comma -14646 # WARNING: modifies name -14647 parse-var-with-type: # name: (addr slice), first-line: (addr stream byte), out: (addr handle var), err: (addr buffered-file), ed: (addr exit-descriptor) -14648 # pseudocode: -14649 # var s: slice -14650 # if (!slice-ends-with(name, ":")) -14651 # abort -14652 # --name->end to skip ':' -14653 # next-token-from-slice(name->start, name->end, '/', s) -14654 # new-var-from-slice(s, out) -14655 # ## register -14656 # next-token-from-slice(s->end, name->end, '/', s) -14657 # if (!slice-empty?(s)) -14658 # out->register = slice-to-string(s) -14659 # ## type -14660 # var type: (handle type-tree) = parse-type(first-line) -14661 # out->type = type -14662 # -14663 # . prologue -14664 55/push-ebp -14665 89/<- %ebp 4/r32/esp -14666 # . save registers -14667 50/push-eax -14668 51/push-ecx -14669 52/push-edx -14670 53/push-ebx -14671 56/push-esi -14672 57/push-edi -14673 # esi = name -14674 8b/-> *(ebp+8) 6/r32/esi -14675 # if (!slice-ends-with?(name, ":")) abort -14676 8b/-> *(esi+4) 1/r32/ecx # Slice-end -14677 49/decrement-ecx -14678 8a/copy-byte *ecx 1/r32/CL -14679 81 4/subop/and %ecx 0xff/imm32 -14680 81 7/subop/compare %ecx 0x3a/imm32/colon -14681 0f 85/jump-if-!= $parse-var-with-type:abort/disp32 -14682 # --name->end to skip ':' -14683 ff 1/subop/decrement *(esi+4) -14684 # var s/ecx: slice -14685 68/push 0/imm32/end -14686 68/push 0/imm32/start -14687 89/<- %ecx 4/r32/esp -14688 $parse-var-with-type:parse-name: -14689 (next-token-from-slice *esi *(esi+4) 0x2f %ecx) # Slice-start, Slice-end, '/' -14690 $parse-var-with-type:create-var: -14691 # new-var-from-slice(s, out) -14692 (new-var-from-slice Heap %ecx *(ebp+0x10)) -14693 # save out->register -14694 $parse-var-with-type:save-register: -14695 # . var out-addr/edi: (addr var) = lookup(*out) -14696 8b/-> *(ebp+0x10) 7/r32/edi -14697 (lookup *edi *(edi+4)) # => eax -14698 89/<- %edi 0/r32/eax -14699 # . s = next-token(...) -14700 (next-token-from-slice *(ecx+4) *(esi+4) 0x2f %ecx) # s->end, name->end, '/' -14701 # . if (!slice-empty?(s)) out->register = slice-to-string(s) -14702 { -14703 $parse-var-with-type:write-register: -14704 (slice-empty? %ecx) # => eax -14705 3d/compare-eax-and 0/imm32/false -14706 75/jump-if-!= break/disp8 -14707 # out->register = slice-to-string(s) -14708 8d/copy-address *(edi+0x18) 0/r32/eax # Var-register -14709 (slice-to-string Heap %ecx %eax) -14710 } -14711 $parse-var-with-type:save-type: -14712 8d/copy-address *(edi+8) 0/r32/eax # Var-type -14713 (parse-type Heap *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) -14714 $parse-var-with-type:end: -14715 # . reclaim locals -14716 81 0/subop/add %esp 8/imm32 -14717 # . restore registers -14718 5f/pop-to-edi -14719 5e/pop-to-esi -14720 5b/pop-to-ebx -14721 5a/pop-to-edx -14722 59/pop-to-ecx -14723 58/pop-to-eax -14724 # . epilogue -14725 89/<- %esp 5/r32/ebp -14726 5d/pop-to-ebp -14727 c3/return -14728 -14729 $parse-var-with-type:abort: -14730 # error("var should have form 'name: type' in '" line "'\n") -14731 (write-buffered *(ebp+0x14) "var should have form 'name: type' in '") -14732 (flush *(ebp+0x14)) -14733 (rewind-stream *(ebp+0xc)) -14734 (write-stream-data *(ebp+0x14) *(ebp+0xc)) -14735 (write-buffered *(ebp+0x14) "'\n") -14736 (flush *(ebp+0x14)) -14737 (stop *(ebp+0x18) 1) -14738 # never gets here -14739 -14740 parse-type: # ad: (addr allocation-descriptor), in: (addr stream byte), out: (addr handle type-tree), err: (addr buffered-file), ed: (addr exit-descriptor) -14741 # pseudocode: -14742 # var s: slice = next-mu-token(in) -14743 # assert s != "" -14744 # assert s != "->" -14745 # assert s != "{" -14746 # assert s != "}" -14747 # if s == ")" -14748 # return -14749 # out = allocate(Type-tree) -14750 # if s != "(" -14751 # HACK: if s is an int, parse and return it -14752 # out->is-atom? = true -14753 # if (s[0] == "_") -14754 # out->value = type-parameter -14755 # out->parameter-name = slice-to-string(ad, s) -14756 # else -14757 # out->value = pos-or-insert-slice(Type-id, s) -14758 # return -14759 # out->left = parse-type(ad, in) -14760 # out->right = parse-type-tree(ad, in) -14761 # -14762 # . prologue -14763 55/push-ebp -14764 89/<- %ebp 4/r32/esp -14765 # . save registers -14766 50/push-eax -14767 51/push-ecx -14768 52/push-edx -14769 # clear out -14770 (zero-out *(ebp+0x10) *Handle-size) -14771 # var s/ecx: slice -14772 68/push 0/imm32 -14773 68/push 0/imm32 -14774 89/<- %ecx 4/r32/esp -14775 # s = next-mu-token(in) -14776 (next-mu-token *(ebp+0xc) %ecx) -14777 #? (write-buffered Stderr "tok: ") -14778 #? (write-slice-buffered Stderr %ecx) -14779 #? (write-buffered Stderr "$\n") -14780 #? (flush Stderr) -14781 # assert s != "" -14782 (slice-equal? %ecx "") # => eax -14783 3d/compare-eax-and 0/imm32/false -14784 0f 85/jump-if-!= $parse-type:abort/disp32 -14785 # assert s != "{" -14786 (slice-equal? %ecx "{") # => eax -14787 3d/compare-eax-and 0/imm32/false -14788 0f 85/jump-if-!= $parse-type:abort/disp32 -14789 # assert s != "}" -14790 (slice-equal? %ecx "}") # => eax -14791 3d/compare-eax-and 0/imm32/false -14792 0f 85/jump-if-!= $parse-type:abort/disp32 -14793 # assert s != "->" -14794 (slice-equal? %ecx "->") # => eax -14795 3d/compare-eax-and 0/imm32/false -14796 0f 85/jump-if-!= $parse-type:abort/disp32 -14797 # if (s == ")") return -14798 (slice-equal? %ecx ")") # => eax -14799 3d/compare-eax-and 0/imm32/false -14800 0f 85/jump-if-!= $parse-type:end/disp32 -14801 # out = new tree -14802 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10)) -14803 # var out-addr/edx: (addr type-tree) = lookup(*out) -14804 8b/-> *(ebp+0x10) 2/r32/edx -14805 (lookup *edx *(edx+4)) # => eax -14806 89/<- %edx 0/r32/eax -14807 { -14808 # if (s != "(") break -14809 (slice-equal? %ecx "(") # => eax -14810 3d/compare-eax-and 0/imm32/false -14811 0f 85/jump-if-!= break/disp32 -14812 # if s is a number, store it in the type's size field -14813 { -14814 $parse-type:check-for-int: -14815 # var tmp/eax: byte = *s->slice -14816 8b/-> *ecx 0/r32/eax -14817 8a/copy-byte *eax 0/r32/AL -14818 81 4/subop/and %eax 0xff/imm32 -14819 # TODO: raise an error on `var x: (array int a)` -14820 (is-decimal-digit? %eax) # => eax -14821 3d/compare-eax-and 0/imm32/false -14822 74/jump-if-= break/disp8 -14823 # -14824 (is-hex-int? %ecx) # => eax -14825 3d/compare-eax-and 0/imm32/false -14826 74/jump-if-= break/disp8 -14827 $parse-type:int: -14828 (check-mu-hex-int %ecx *(ebp+0x14) *(ebp+0x18)) -14829 (parse-hex-int-from-slice %ecx) # => eax -14830 c7 0/subop/copy *(edx+4) 9/imm32/type-id-array-capacity # Type-tree-value -14831 89/<- *(edx+8) 0/r32/eax # Type-tree-value-size -14832 e9/jump $parse-type:end/disp32 -14833 } -14834 $parse-type:atom: -14835 # out->is-atom? = true -14836 c7 0/subop/copy *edx 1/imm32/true # Type-tree-is-atom -14837 { -14838 $parse-type:check-for-type-parameter: -14839 # var tmp/eax: byte = *s->slice -14840 8b/-> *ecx 0/r32/eax -14841 8a/copy-byte *eax 0/r32/AL -14842 81 4/subop/and %eax 0xff/imm32 -14843 # if (tmp != '_') break -14844 3d/compare-eax-and 0x5f/imm32/_ -14845 75/jump-if-!= break/disp8 -14846 $parse-type:type-parameter: -14847 # out->value = type-parameter -14848 c7 0/subop/copy *(edx+4) 0xa/imm32/type-parameter # Type-tree-value -14849 # out->parameter-name = slice-to-string(ad, s) -14850 8d/copy-address *(edx+8) 0/r32/eax # Type-tree-parameter-name -14851 (slice-to-string *(ebp+8) %ecx %eax) -14852 e9/jump $parse-type:end/disp32 -14853 } -14854 $parse-type:non-type-parameter: -14855 # out->value = pos-or-insert-slice(Type-id, s) -14856 (pos-or-insert-slice Type-id %ecx) # => eax -14857 89/<- *(edx+4) 0/r32/eax # Type-tree-value -14858 e9/jump $parse-type:end/disp32 -14859 } -14860 $parse-type:non-atom: -14861 # otherwise s == "(" -14862 # out->left = parse-type(ad, in) -14863 8d/copy-address *(edx+4) 0/r32/eax # Type-tree-left -14864 (parse-type *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) -14865 # out->right = parse-type-tree(ad, in) -14866 8d/copy-address *(edx+0xc) 0/r32/eax # Type-tree-right -14867 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) -14868 $parse-type:end: -14869 # . reclaim locals -14870 81 0/subop/add %esp 8/imm32 -14871 # . restore registers -14872 5a/pop-to-edx -14873 59/pop-to-ecx -14874 58/pop-to-eax -14875 # . epilogue -14876 89/<- %esp 5/r32/ebp -14877 5d/pop-to-ebp -14878 c3/return -14879 -14880 $parse-type:abort: -14881 # error("unexpected token when parsing type: '" s "'\n") -14882 (write-buffered *(ebp+0x14) "unexpected token when parsing type: '") -14883 (write-slice-buffered *(ebp+0x14) %ecx) -14884 (write-buffered *(ebp+0x14) "'\n") -14885 (flush *(ebp+0x14)) -14886 (stop *(ebp+0x18) 1) -14887 # never gets here -14888 -14889 parse-type-tree: # ad: (addr allocation-descriptor), in: (addr stream byte), out: (addr handle type-tree), err: (addr buffered-file), ed: (addr exit-descriptor) -14890 # pseudocode: -14891 # var tmp: (handle type-tree) = parse-type(ad, in) -14892 # if tmp == 0 -14893 # return 0 -14894 # out = allocate(Type-tree) -14895 # out->left = tmp -14896 # out->right = parse-type-tree(ad, in) -14897 # -14898 # . prologue -14899 55/push-ebp -14900 89/<- %ebp 4/r32/esp -14901 # . save registers -14902 50/push-eax -14903 51/push-ecx -14904 52/push-edx -14905 # -14906 (zero-out *(ebp+0x10) *Handle-size) -14907 # var tmp/ecx: (handle type-tree) -14908 68/push 0/imm32 -14909 68/push 0/imm32 -14910 89/<- %ecx 4/r32/esp -14911 # tmp = parse-type(ad, in) -14912 (parse-type *(ebp+8) *(ebp+0xc) %ecx *(ebp+0x14) *(ebp+0x18)) -14913 # if (tmp == 0) return -14914 81 7/subop/compare *ecx 0/imm32 -14915 74/jump-if-= $parse-type-tree:end/disp8 -14916 # out = new tree -14917 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10)) -14918 # var out-addr/edx: (addr tree) = lookup(*out) -14919 8b/-> *(ebp+0x10) 2/r32/edx -14920 (lookup *edx *(edx+4)) # => eax -14921 89/<- %edx 0/r32/eax -14922 # out->left = tmp -14923 8b/-> *ecx 0/r32/eax -14924 89/<- *(edx+4) 0/r32/eax # Type-tree-left -14925 8b/-> *(ecx+4) 0/r32/eax -14926 89/<- *(edx+8) 0/r32/eax # Type-tree-left -14927 # out->right = parse-type-tree(ad, in) -14928 8d/copy-address *(edx+0xc) 0/r32/eax # Type-tree-right -14929 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) -14930 $parse-type-tree:end: -14931 # . reclaim locals -14932 81 0/subop/add %esp 8/imm32 -14933 # . restore registers -14934 5a/pop-to-edx -14935 59/pop-to-ecx -14936 58/pop-to-eax -14937 # . epilogue -14938 89/<- %esp 5/r32/ebp -14939 5d/pop-to-ebp -14940 c3/return -14941 -14942 next-mu-token: # in: (addr stream byte), out: (addr slice) -14943 # pseudocode: -14944 # start: -14945 # skip-chars-matching-whitespace(in) -14946 # if in->read >= in->write # end of in -14947 # out = {0, 0} -14948 # return -14949 # out->start = &in->data[in->read] -14950 # var curr-byte/eax: byte = in->data[in->read] -14951 # if curr->byte == ',' # comment token -14952 # ++in->read -14953 # goto start -14954 # if curr-byte == '#' # comment -14955 # goto done # treat as eof -14956 # if curr-byte == '"' # string literal -14957 # skip-string(in) -14958 # goto done # no metadata -14959 # if curr-byte == '(' -14960 # ++in->read -14961 # goto done -14962 # if curr-byte == ')' -14963 # ++in->read -14964 # goto done -14965 # # read a word -14966 # while true -14967 # if in->read >= in->write -14968 # break -14969 # curr-byte = in->data[in->read] -14970 # if curr-byte == ' ' -14971 # break -14972 # if curr-byte == '\r' -14973 # break -14974 # if curr-byte == '\n' -14975 # break -14976 # if curr-byte == '(' -14977 # break -14978 # if curr-byte == ')' -14979 # break -14980 # if curr-byte == ',' -14981 # break -14982 # ++in->read -14983 # done: -14984 # out->end = &in->data[in->read] -14985 # -14986 # . prologue -14987 55/push-ebp -14988 89/<- %ebp 4/r32/esp -14989 # . save registers -14990 50/push-eax -14991 51/push-ecx -14992 56/push-esi -14993 57/push-edi -14994 # esi = in -14995 8b/-> *(ebp+8) 6/r32/esi -14996 # edi = out -14997 8b/-> *(ebp+0xc) 7/r32/edi -14998 $next-mu-token:start: -14999 (skip-chars-matching-whitespace %esi) -15000 $next-mu-token:check0: -15001 # if (in->read >= in->write) return out = {0, 0} -15002 # . ecx = in->read -15003 8b/-> *(esi+4) 1/r32/ecx -15004 # . if (ecx >= in->write) return out = {0, 0} -15005 3b/compare<- *esi 1/r32/ecx -15006 c7 0/subop/copy *edi 0/imm32 -15007 c7 0/subop/copy *(edi+4) 0/imm32 -15008 0f 8d/jump-if->= $next-mu-token:end/disp32 -15009 # out->start = &in->data[in->read] -15010 8d/copy-address *(esi+ecx+0xc) 0/r32/eax -15011 89/<- *edi 0/r32/eax -15012 # var curr-byte/eax: byte = in->data[in->read] -15013 31/xor-with %eax 0/r32/eax -15014 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL -15015 { -15016 $next-mu-token:check-for-comma: -15017 # if (curr-byte != ',') break -15018 3d/compare-eax-and 0x2c/imm32/comma -15019 75/jump-if-!= break/disp8 -15020 # ++in->read -15021 ff 0/subop/increment *(esi+4) -15022 # restart -15023 e9/jump $next-mu-token:start/disp32 -15024 } -15025 { -15026 $next-mu-token:check-for-comment: -15027 # if (curr-byte != '#') break -15028 3d/compare-eax-and 0x23/imm32/pound -15029 75/jump-if-!= break/disp8 -15030 # return eof -15031 e9/jump $next-mu-token:done/disp32 -15032 } -15033 { -15034 $next-mu-token:check-for-string-literal: -15035 # if (curr-byte != '"') break -15036 3d/compare-eax-and 0x22/imm32/dquote -15037 75/jump-if-!= break/disp8 -15038 (skip-string %esi) -15039 # return -15040 e9/jump $next-mu-token:done/disp32 -15041 } -15042 { -15043 $next-mu-token:check-for-open-paren: -15044 # if (curr-byte != '(') break -15045 3d/compare-eax-and 0x28/imm32/open-paren -15046 75/jump-if-!= break/disp8 -15047 # ++in->read -15048 ff 0/subop/increment *(esi+4) -15049 # return -15050 e9/jump $next-mu-token:done/disp32 -15051 } -15052 { -15053 $next-mu-token:check-for-close-paren: -15054 # if (curr-byte != ')') break -15055 3d/compare-eax-and 0x29/imm32/close-paren -15056 75/jump-if-!= break/disp8 -15057 # ++in->read -15058 ff 0/subop/increment *(esi+4) -15059 # return -15060 e9/jump $next-mu-token:done/disp32 -15061 } -15062 { -15063 $next-mu-token:regular-word-without-metadata: -15064 # if (in->read >= in->write) break -15065 # . ecx = in->read -15066 8b/-> *(esi+4) 1/r32/ecx -15067 # . if (ecx >= in->write) break -15068 3b/compare<- *esi 1/r32/ecx -15069 7d/jump-if->= break/disp8 -15070 # var c/eax: byte = in->data[in->read] -15071 31/xor-with %eax 0/r32/eax -15072 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL -15073 # if (c == ' ') break -15074 3d/compare-eax-and 0x20/imm32/space -15075 74/jump-if-= break/disp8 -15076 # if (c == '\r') break -15077 3d/compare-eax-and 0xd/imm32/carriage-return -15078 74/jump-if-= break/disp8 -15079 # if (c == '\n') break -15080 3d/compare-eax-and 0xa/imm32/newline -15081 74/jump-if-= break/disp8 -15082 # if (c == '(') break -15083 3d/compare-eax-and 0x28/imm32/open-paren -15084 0f 84/jump-if-= break/disp32 -15085 # if (c == ')') break -15086 3d/compare-eax-and 0x29/imm32/close-paren -15087 0f 84/jump-if-= break/disp32 -15088 # if (c == ',') break -15089 3d/compare-eax-and 0x2c/imm32/comma -15090 0f 84/jump-if-= break/disp32 -15091 # ++in->read -15092 ff 0/subop/increment *(esi+4) -15093 # -15094 e9/jump loop/disp32 -15095 } -15096 $next-mu-token:done: -15097 # out->end = &in->data[in->read] -15098 8b/-> *(esi+4) 1/r32/ecx -15099 8d/copy-address *(esi+ecx+0xc) 0/r32/eax -15100 89/<- *(edi+4) 0/r32/eax -15101 $next-mu-token:end: -15102 # . restore registers -15103 5f/pop-to-edi -15104 5e/pop-to-esi -15105 59/pop-to-ecx -15106 58/pop-to-eax -15107 # . epilogue -15108 89/<- %esp 5/r32/ebp -15109 5d/pop-to-ebp -15110 c3/return -15111 -15112 pos-or-insert-slice: # arr: (addr stream (addr array byte)), s: (addr slice) -> index/eax: int -15113 # . prologue -15114 55/push-ebp -15115 89/<- %ebp 4/r32/esp -15116 # if (pos-slice(arr, s) != -1) return it -15117 (pos-slice *(ebp+8) *(ebp+0xc)) # => eax -15118 3d/compare-eax-and -1/imm32 -15119 75/jump-if-!= $pos-or-insert-slice:end/disp8 -15120 $pos-or-insert-slice:insert: -15121 # var s2/eax: (handle array byte) -15122 68/push 0/imm32 -15123 68/push 0/imm32 -15124 89/<- %eax 4/r32/esp -15125 (slice-to-string Heap *(ebp+0xc) %eax) -15126 # throw away alloc-id -15127 (lookup *eax *(eax+4)) # => eax -15128 (write-int *(ebp+8) %eax) -15129 (pos-slice *(ebp+8) *(ebp+0xc)) # => eax -15130 $pos-or-insert-slice:end: -15131 # . reclaim locals -15132 81 0/subop/add %esp 8/imm32 -15133 # . epilogue -15134 89/<- %esp 5/r32/ebp -15135 5d/pop-to-ebp -15136 c3/return -15137 -15138 # return the index in an array of strings matching 's', -1 if not found -15139 # index is denominated in elements, not bytes -15140 pos-slice: # arr: (addr stream (addr array byte)), s: (addr slice) -> index/eax: int -15141 # . prologue -15142 55/push-ebp -15143 89/<- %ebp 4/r32/esp -15144 # . save registers -15145 51/push-ecx -15146 52/push-edx -15147 53/push-ebx -15148 56/push-esi -15149 #? (write-buffered Stderr "pos-slice: ") -15150 #? (write-slice-buffered Stderr *(ebp+0xc)) -15151 #? (write-buffered Stderr "\n") -15152 #? (flush Stderr) -15153 # esi = arr -15154 8b/-> *(ebp+8) 6/r32/esi -15155 # var index/ecx: int = 0 -15156 b9/copy-to-ecx 0/imm32 -15157 # var curr/edx: (addr (addr array byte)) = arr->data -15158 8d/copy-address *(esi+0xc) 2/r32/edx -15159 # var max/ebx: (addr (addr array byte)) = &arr->data[arr->write] -15160 8b/-> *esi 3/r32/ebx -15161 8d/copy-address *(esi+ebx+0xc) 3/r32/ebx -15162 { -15163 #? (write-buffered Stderr " ") -15164 #? (write-int32-hex-buffered Stderr %ecx) -15165 #? (write-buffered Stderr "\n") -15166 #? (flush Stderr) -15167 # if (curr >= max) return -1 -15168 39/compare %edx 3/r32/ebx -15169 b8/copy-to-eax -1/imm32 -15170 73/jump-if-addr>= $pos-slice:end/disp8 -15171 # if (slice-equal?(s, *curr)) break -15172 (slice-equal? *(ebp+0xc) *edx) # => eax -15173 3d/compare-eax-and 0/imm32/false -15174 75/jump-if-!= break/disp8 -15175 # ++index -15176 41/increment-ecx -15177 # curr += 4 -15178 81 0/subop/add %edx 4/imm32 -15179 # -15180 eb/jump loop/disp8 -15181 } -15182 # return index -15183 89/<- %eax 1/r32/ecx -15184 $pos-slice:end: -15185 #? (write-buffered Stderr "=> ") -15186 #? (write-int32-hex-buffered Stderr %eax) -15187 #? (write-buffered Stderr "\n") -15188 # . restore registers -15189 5e/pop-to-esi -15190 5b/pop-to-ebx -15191 5a/pop-to-edx -15192 59/pop-to-ecx -15193 # . epilogue -15194 89/<- %esp 5/r32/ebp -15195 5d/pop-to-ebp -15196 c3/return -15197 -15198 test-parse-var-with-type: -15199 # . prologue -15200 55/push-ebp -15201 89/<- %ebp 4/r32/esp -15202 # setup -15203 8b/-> *Primitive-type-ids 0/r32/eax -15204 89/<- *Type-id 0/r32/eax # stream-write -15205 # (eax..ecx) = "x:" -15206 b8/copy-to-eax "x:"/imm32 -15207 8b/-> *eax 1/r32/ecx -15208 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15209 05/add-to-eax 4/imm32 -15210 # var slice/ecx: slice = {eax, ecx} -15211 51/push-ecx -15212 50/push-eax -15213 89/<- %ecx 4/r32/esp -15214 # _test-input-stream contains "int" +14400 $parse-mu:error2: +14401 # error(vars->top " vars not reclaimed after fn '" new-function->name "'\n") +14402 (write-int32-hex-buffered *(ebp+0xc) *ebx) +14403 (write-buffered *(ebp+0xc) " vars not reclaimed after fn '") +14404 (write-slice-buffered *(ebp+0xc) *eax) # Function-name +14405 (write-buffered *(ebp+0xc) "'\n") +14406 (flush *(ebp+0xc)) +14407 (stop *(ebp+0x10) 1) +14408 # never gets here +14409 +14410 # scenarios considered: +14411 # ✗ fn foo # no block +14412 # ✓ fn foo { +14413 # ✗ fn foo { { +14414 # ✗ fn foo { } +14415 # ✗ fn foo { } { +14416 # ✗ fn foo x { +14417 # ✗ fn foo x: { +14418 # ✓ fn foo x: int { +14419 # ✓ fn foo x: int { +14420 # ✓ fn foo x: int -> _/eax: int { +14421 # TODO: +14422 # disallow outputs of type `(... addr ...)` +14423 # disallow inputs of type `(... addr ... addr ...)` +14424 populate-mu-function-header: # first-line: (addr stream byte), out: (addr function), vars: (addr stack live-var), err: (addr buffered-file), ed: (addr exit-descriptor) +14425 # pseudocode: +14426 # var word-slice: slice +14427 # next-mu-token(first-line, word-slice) +14428 # if slice-empty?(word-slice) abort +14429 # assert(word-slice not in '{' '}' '->') +14430 # out->name = slice-to-string(word-slice) +14431 # ## inouts +14432 # while true +14433 # word-slice = next-mu-token(first-line) +14434 # if slice-empty?(word-slice) abort +14435 # if (word-slice == '{') goto done +14436 # if (word-slice == '->') break +14437 # assert(word-slice != '}') +14438 # var v: (handle var) = parse-var-with-type(word-slice, first-line) +14439 # assert(v->register == null) +14440 # # v->block-depth is implicitly 0 +14441 # out->inouts = append(v, out->inouts) +14442 # push(vars, {v, false}) +14443 # ## outputs +14444 # while true +14445 # word-slice = next-mu-token(first-line) +14446 # if slice-empty?(word-slice) abort +14447 # if (word-slice == '{') break +14448 # assert(word-slice not in '}' '->') +14449 # var v: (handle var) = parse-var-with-type(word-slice, first-line) +14450 # assert(v->register != null) +14451 # assert(v->name == "_") +14452 # out->outputs = append(v, out->outputs) +14453 # done: +14454 # +14455 # . prologue +14456 55/push-ebp +14457 89/<- %ebp 4/r32/esp +14458 # . save registers +14459 50/push-eax +14460 51/push-ecx +14461 52/push-edx +14462 53/push-ebx +14463 57/push-edi +14464 # edi = out +14465 8b/-> *(ebp+0xc) 7/r32/edi +14466 # var word-slice/ecx: slice +14467 68/push 0/imm32/end +14468 68/push 0/imm32/start +14469 89/<- %ecx 4/r32/esp +14470 # var v/ebx: (handle var) +14471 68/push 0/imm32 +14472 68/push 0/imm32 +14473 89/<- %ebx 4/r32/esp +14474 # read function name +14475 (next-mu-token *(ebp+8) %ecx) +14476 # error checking +14477 # if slice-empty?(word-slice) abort +14478 (slice-empty? %ecx) # => eax +14479 3d/compare-eax-and 0/imm32/false +14480 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 +14481 # if (word-slice == '{') abort +14482 (slice-equal? %ecx "{") # => eax +14483 3d/compare-eax-and 0/imm32/false +14484 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 +14485 # if (word-slice == '->') abort +14486 (slice-equal? %ecx "->") # => eax +14487 3d/compare-eax-and 0/imm32/false +14488 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 +14489 # if (word-slice == '}') abort +14490 (slice-equal? %ecx "}") # => eax +14491 3d/compare-eax-and 0/imm32/false +14492 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 +14493 # if word-slice already defined, abort +14494 (function-exists? %ecx) # => eax +14495 3d/compare-eax-and 0/imm32/false +14496 0f 85/jump-if-!= $populate-mu-function-header:error-duplicate/disp32 +14497 # +14498 (slice-starts-with? %ecx "break") # => eax +14499 3d/compare-eax-and 0/imm32/false +14500 0f 85/jump-if-!= $populate-mu-function-header:error-break/disp32 +14501 (slice-starts-with? %ecx "loop") # => eax +14502 3d/compare-eax-and 0/imm32/false +14503 0f 85/jump-if-!= $populate-mu-function-header:error-loop/disp32 +14504 (slice-equal? %ecx "lookup") # => eax +14505 3d/compare-eax-and 0/imm32/false +14506 0f 85/jump-if-!= $populate-mu-function-header:error-lookup/disp32 +14507 # save function name +14508 (slice-to-string Heap %ecx %edi) # Function-name +14509 # save function inouts +14510 { +14511 $populate-mu-function-header:check-for-inout: +14512 (next-mu-token *(ebp+8) %ecx) +14513 # if slice-empty?(word-slice) abort +14514 (slice-empty? %ecx) # => eax +14515 3d/compare-eax-and 0/imm32/false +14516 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 +14517 # if (word-slice == '{') goto done +14518 (slice-equal? %ecx "{") # => eax +14519 3d/compare-eax-and 0/imm32/false +14520 0f 85/jump-if-!= $populate-mu-function-header:done/disp32 +14521 # if (word-slice == '->') break +14522 (slice-equal? %ecx "->") # => eax +14523 3d/compare-eax-and 0/imm32/false +14524 0f 85/jump-if-!= break/disp32 +14525 # if (word-slice == '}') abort +14526 (slice-equal? %ecx "}") # => eax +14527 3d/compare-eax-and 0/imm32/false +14528 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 +14529 # v = parse-var-with-type(word-slice, first-line) +14530 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14531 (parse-var-with-type %ecx *(ebp+8) %ebx %eax *(ebp+0x14) *(ebp+0x18)) +14532 # if (v->register != null) abort +14533 # . eax: (addr var) = lookup(v) +14534 (lookup *ebx *(ebx+4)) # => eax +14535 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +14536 0f 85/jump-if-!= $populate-mu-function-header:error2/disp32 +14537 # if function name is not "main" +14538 # and v->type contains an 'addr' anywhere except the start, abort +14539 { +14540 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14541 (string-equal? %eax "main") # => eax +14542 3d/compare-eax-and 0/imm32/false +14543 75/jump-if-!= break/disp8 +14544 (lookup *ebx *(ebx+4)) # => eax +14545 (addr-payload-contains-addr? %eax) # => eax +14546 3d/compare-eax-and 0/imm32/false +14547 0f 85/jump-if-!= $populate-mu-function-header:error-nested-addr-inout/disp32 +14548 } +14549 # v->block-depth is implicitly 0 +14550 # +14551 # out->inouts = append(v, out->inouts) +14552 8d/copy-address *(edi+8) 0/r32/eax # Function-inouts +14553 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax) # Function-inouts, Function-inouts +14554 # push(vars, {v, false}) +14555 (push *(ebp+0x10) *ebx) +14556 (push *(ebp+0x10) *(ebx+4)) +14557 (push *(ebp+0x10) 0) # false +14558 # +14559 e9/jump loop/disp32 +14560 } +14561 # save function outputs +14562 { +14563 $populate-mu-function-header:check-for-out: +14564 (next-mu-token *(ebp+8) %ecx) +14565 # if slice-empty?(word-slice) abort +14566 (slice-empty? %ecx) # => eax +14567 3d/compare-eax-and 0/imm32/false +14568 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 +14569 # if (word-slice == '{') break +14570 (slice-equal? %ecx "{") # => eax +14571 3d/compare-eax-and 0/imm32/false +14572 0f 85/jump-if-!= break/disp32 +14573 # if (word-slice == '->') abort +14574 (slice-equal? %ecx "->") # => eax +14575 3d/compare-eax-and 0/imm32/false +14576 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 +14577 # if (word-slice == '}') abort +14578 (slice-equal? %ecx "}") # => eax +14579 3d/compare-eax-and 0/imm32/false +14580 0f 85/jump-if-!= $populate-mu-function-header:error1/disp32 +14581 # v = parse-var-with-type(word-slice, first-line) +14582 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14583 (parse-var-with-type %ecx *(ebp+8) %ebx %eax *(ebp+0x14) *(ebp+0x18)) +14584 # assert(var->register != null) +14585 # . eax: (addr var) = lookup(v) +14586 (lookup *ebx *(ebx+4)) # => eax +14587 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +14588 0f 84/jump-if-= $populate-mu-function-header:error3/disp32 +14589 # if (var->name != "_") abort +14590 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14591 (string-equal? %eax "_") # => eax +14592 3d/compare-eax-and 0/imm32/false +14593 0f 84/jump-if-= $populate-mu-function-header:error4/disp32 +14594 # if v->type is an addr, abort +14595 (lookup *ebx *(ebx+4)) # => eax +14596 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +14597 (is-mu-addr-type? %eax) # => eax +14598 3d/compare-eax-and 0/imm32/false +14599 0f 85/jump-if-!= $populate-mu-function-header:error-addr-output/disp32 +14600 # out->outputs = append(v, out->outputs) +14601 8d/copy-address *(edi+0x10) 0/r32/eax # Function-outputs +14602 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax) # Function-outputs, Function-outputs +14603 # +14604 e9/jump loop/disp32 +14605 } +14606 $populate-mu-function-header:done: +14607 (check-no-tokens-left *(ebp+8)) +14608 $populate-mu-function-header:end: +14609 # . reclaim locals +14610 81 0/subop/add %esp 0x10/imm32 +14611 # . restore registers +14612 5f/pop-to-edi +14613 5b/pop-to-ebx +14614 5a/pop-to-edx +14615 59/pop-to-ecx +14616 58/pop-to-eax +14617 # . epilogue +14618 89/<- %esp 5/r32/ebp +14619 5d/pop-to-ebp +14620 c3/return +14621 +14622 $populate-mu-function-header:error1: +14623 # error("function header not in form 'fn <name> {'") +14624 (write-buffered *(ebp+0x14) "function header not in form 'fn <name> [inouts] [-> outputs] {' -- '") +14625 (flush *(ebp+0x14)) +14626 (rewind-stream *(ebp+8)) +14627 (write-stream-data *(ebp+0x14) *(ebp+8)) +14628 (write-buffered *(ebp+0x14) "'\n") +14629 (flush *(ebp+0x14)) +14630 (stop *(ebp+0x18) 1) +14631 # never gets here +14632 +14633 $populate-mu-function-header:error2: +14634 # error("fn " fn ": function inout '" var "' cannot be in a register") +14635 (write-buffered *(ebp+0x14) "fn ") +14636 50/push-eax +14637 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14638 (write-buffered *(ebp+0x14) %eax) +14639 58/pop-to-eax +14640 (write-buffered *(ebp+0x14) ": function inout '") +14641 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14642 (write-buffered *(ebp+0x14) %eax) +14643 (write-buffered *(ebp+0x14) "' cannot be in a register") +14644 (flush *(ebp+0x14)) +14645 (stop *(ebp+0x18) 1) +14646 # never gets here +14647 +14648 $populate-mu-function-header:error3: +14649 # error("fn " fn ": function output '" var "' must be in a register") +14650 (write-buffered *(ebp+0x14) "fn ") +14651 50/push-eax +14652 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14653 (write-buffered *(ebp+0x14) %eax) +14654 58/pop-to-eax +14655 (write-buffered *(ebp+0x14) ": function output '") +14656 (lookup *ebx *(ebx+4)) # => eax +14657 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14658 (write-buffered *(ebp+0x14) %eax) +14659 (write-buffered *(ebp+0x14) "' must be in a register, in instruction '") +14660 (rewind-stream *(ebp+8)) +14661 (write-stream-data *(ebp+0x14) *(ebp+8)) +14662 (write-buffered *(ebp+0x14) "'\n") +14663 (flush *(ebp+0x14)) +14664 (stop *(ebp+0x18) 1) +14665 # never gets here +14666 +14667 $populate-mu-function-header:error4: +14668 # error("fn " fn ": function outputs cannot be named; rename '" var "' in the header to '_'") +14669 (write-buffered *(ebp+0x14) "fn ") +14670 50/push-eax +14671 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14672 (write-buffered *(ebp+0x14) %eax) +14673 58/pop-to-eax +14674 (write-buffered *(ebp+0x14) ": function outputs cannot be named; rename '") +14675 (lookup *ebx *(ebx+4)) # => eax +14676 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14677 (write-buffered *(ebp+0x14) %eax) +14678 (write-buffered *(ebp+0x14) "' in the header to '_'\n") +14679 (flush *(ebp+0x14)) +14680 (stop *(ebp+0x18) 1) +14681 # never gets here +14682 +14683 $populate-mu-function-header:error-duplicate: +14684 (write-buffered *(ebp+0x14) "fn ") +14685 (write-slice-buffered *(ebp+0x14) %ecx) +14686 (write-buffered *(ebp+0x14) " defined more than once\n") +14687 (flush *(ebp+0x14)) +14688 (stop *(ebp+0x18) 1) +14689 # never gets here +14690 +14691 $populate-mu-function-header:error-break: +14692 (write-buffered *(ebp+0x14) "Sorry, I've reserved all function names starting with 'break' for now. Please contact mu@akkartik.com.\n") +14693 (flush *(ebp+0x14)) +14694 (stop *(ebp+0x18) 1) +14695 # never gets here +14696 +14697 $populate-mu-function-header:error-loop: +14698 (write-buffered *(ebp+0x14) "Sorry, I've reserved all function names starting with 'loop' for now. Please contact mu@akkartik.com.\n") +14699 (flush *(ebp+0x14)) +14700 (stop *(ebp+0x18) 1) +14701 # never gets here +14702 +14703 $populate-mu-function-header:error-lookup: +14704 (write-buffered *(ebp+0x14) "cannot define a function called 'lookup'\n") +14705 (flush *(ebp+0x14)) +14706 (stop *(ebp+0x18) 1) +14707 # never gets here +14708 +14709 $populate-mu-function-header:error-addr-output: +14710 # error("fn " fn ": output cannot have an addr type; that could allow unsafe addresses to escape the function") +14711 (write-buffered *(ebp+0x14) "fn ") +14712 50/push-eax +14713 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14714 (write-buffered *(ebp+0x14) %eax) +14715 58/pop-to-eax +14716 (write-buffered *(ebp+0x14) ": output cannot have an addr type; that could allow unsafe addresses to escape the function\n") +14717 (flush *(ebp+0x14)) +14718 (stop *(ebp+0x18) 1) +14719 # never gets here +14720 +14721 $populate-mu-function-header:error-nested-addr-inout: +14722 # error("fn " fn ": inout '" var "' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function") +14723 (write-buffered *(ebp+0x14) "fn ") +14724 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14725 (write-buffered *(ebp+0x14) %eax) +14726 (write-buffered *(ebp+0x14) ": inout '") +14727 (lookup *ebx *(ebx+4)) # => eax +14728 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14729 (write-buffered *(ebp+0x14) %eax) +14730 (write-buffered *(ebp+0x14) "' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function\n") +14731 (flush *(ebp+0x14)) +14732 (stop *(ebp+0x18) 1) +14733 # never gets here +14734 +14735 # scenarios considered: +14736 # ✓ fn foo +14737 # ✗ fn foo { +14738 # ✓ fn foo x +14739 # ✓ fn foo x: int +14740 # ✓ fn foo x: int -> _/eax: int +14741 # TODO: +14742 # disallow outputs of type `(... addr ...)` +14743 # disallow inputs of type `(... addr ... addr ...)` +14744 populate-mu-function-signature: # first-line: (addr stream byte), out: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +14745 # pseudocode: +14746 # var word-slice: slice +14747 # next-mu-token(first-line, word-slice) +14748 # assert(word-slice not in '{' '}' '->') +14749 # out->name = slice-to-string(word-slice) +14750 # ## inouts +14751 # while true +14752 # word-slice = next-mu-token(first-line) +14753 # if slice-empty?(word-slice) break +14754 # if (word-slice == '->') break +14755 # assert(word-slice not in '{' '}') +14756 # var v: (handle var) = parse-var-with-type(word-slice, first-line) +14757 # assert(v->register == null) +14758 # # v->block-depth is implicitly 0 +14759 # out->inouts = append(v, out->inouts) +14760 # ## outputs +14761 # while true +14762 # word-slice = next-mu-token(first-line) +14763 # if slice-empty?(word-slice) break +14764 # assert(word-slice not in '{' '}' '->') +14765 # var v: (handle var) = parse-var-with-type(word-slice, first-line) +14766 # assert(v->register != null) +14767 # out->outputs = append(v, out->outputs) +14768 # +14769 # . prologue +14770 55/push-ebp +14771 89/<- %ebp 4/r32/esp +14772 # . save registers +14773 50/push-eax +14774 51/push-ecx +14775 52/push-edx +14776 53/push-ebx +14777 57/push-edi +14778 # edi = out +14779 8b/-> *(ebp+0xc) 7/r32/edi +14780 # var word-slice/ecx: slice +14781 68/push 0/imm32/end +14782 68/push 0/imm32/start +14783 89/<- %ecx 4/r32/esp +14784 # var v/ebx: (handle var) +14785 68/push 0/imm32 +14786 68/push 0/imm32 +14787 89/<- %ebx 4/r32/esp +14788 # read function name +14789 (next-mu-token *(ebp+8) %ecx) +14790 # error checking +14791 # if (word-slice == '{') abort +14792 (slice-equal? %ecx "{") # => eax +14793 3d/compare-eax-and 0/imm32/false +14794 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 +14795 # if (word-slice == '->') abort +14796 (slice-equal? %ecx "->") # => eax +14797 3d/compare-eax-and 0/imm32/false +14798 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 +14799 # if (word-slice == '}') abort +14800 (slice-equal? %ecx "}") # => eax +14801 3d/compare-eax-and 0/imm32/false +14802 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 +14803 # if word-slice already defined, abort +14804 (function-exists? %ecx) # => eax +14805 3d/compare-eax-and 0/imm32/false +14806 0f 85/jump-if-!= $populate-mu-function-signature:error-duplicate/disp32 +14807 # +14808 (slice-starts-with? %ecx "break") # => eax +14809 3d/compare-eax-and 0/imm32/false +14810 0f 85/jump-if-!= $populate-mu-function-signature:error-break/disp32 +14811 (slice-starts-with? %ecx "loop") # => eax +14812 3d/compare-eax-and 0/imm32/false +14813 0f 85/jump-if-!= $populate-mu-function-signature:error-loop/disp32 +14814 # save function name +14815 (slice-to-string Heap %ecx %edi) # Function-name +14816 # save function inouts +14817 { +14818 $populate-mu-function-signature:check-for-inout: +14819 (next-mu-token *(ebp+8) %ecx) +14820 (slice-empty? %ecx) # => eax +14821 3d/compare-eax-and 0/imm32/false +14822 0f 85/jump-if-!= break/disp32 +14823 # if (word-slice == '->') break +14824 (slice-equal? %ecx "->") # => eax +14825 3d/compare-eax-and 0/imm32/false +14826 0f 85/jump-if-!= break/disp32 +14827 # if (word-slice == '{') abort +14828 (slice-equal? %ecx "{") # => eax +14829 3d/compare-eax-and 0/imm32/false +14830 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 +14831 # if (word-slice == '}') abort +14832 (slice-equal? %ecx "}") # => eax +14833 3d/compare-eax-and 0/imm32/false +14834 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 +14835 # v = parse-var-with-type(word-slice, first-line) +14836 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14837 (parse-var-with-type %ecx *(ebp+8) %ebx %eax *(ebp+0x10) *(ebp+0x14)) +14838 # if (v->register != null) abort +14839 # . eax: (addr var) = lookup(v) +14840 (lookup *ebx *(ebx+4)) # => eax +14841 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +14842 0f 85/jump-if-!= $populate-mu-function-signature:error2/disp32 +14843 # if function name is not "main" +14844 # and v->type contains an 'addr' anywhere except the start, abort +14845 { +14846 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14847 (string-equal? %eax "main") # => eax +14848 3d/compare-eax-and 0/imm32/false +14849 75/jump-if-!= break/disp8 +14850 (lookup *ebx *(ebx+4)) # => eax +14851 (addr-payload-contains-addr? %eax) # => eax +14852 3d/compare-eax-and 0/imm32/false +14853 0f 85/jump-if-!= $populate-mu-function-signature:error-nested-addr-inout/disp32 +14854 } +14855 # assert(v->register == null) +14856 # . eax: (addr var) = lookup(v) +14857 (lookup *ebx *(ebx+4)) # => eax +14858 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +14859 0f 85/jump-if-!= $populate-mu-function-signature:error2/disp32 +14860 # v->block-depth is implicitly 0 +14861 # +14862 # out->inouts = append(v, out->inouts) +14863 8d/copy-address *(edi+8) 0/r32/eax # Function-inouts +14864 (append-list Heap *ebx *(ebx+4) *(edi+8) *(edi+0xc) %eax) # Function-inouts, Function-inouts +14865 # +14866 e9/jump loop/disp32 +14867 } +14868 # save function outputs +14869 { +14870 $populate-mu-function-signature:check-for-out: +14871 (next-mu-token *(ebp+8) %ecx) +14872 (slice-empty? %ecx) # => eax +14873 3d/compare-eax-and 0/imm32/false +14874 0f 85/jump-if-!= break/disp32 +14875 # if (word-slice == '{') abort +14876 (slice-equal? %ecx "{") # => eax +14877 3d/compare-eax-and 0/imm32/false +14878 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 +14879 # if (word-slice == '->') abort +14880 (slice-equal? %ecx "->") # => eax +14881 3d/compare-eax-and 0/imm32/false +14882 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 +14883 # if (word-slice == '}') abort +14884 (slice-equal? %ecx "}") # => eax +14885 3d/compare-eax-and 0/imm32/false +14886 0f 85/jump-if-!= $populate-mu-function-signature:error1/disp32 +14887 # v = parse-var-with-type(word-slice, first-line) +14888 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14889 (parse-var-with-type %ecx *(ebp+8) %ebx %eax *(ebp+0x10) *(ebp+0x14)) +14890 # assert(var->register != null) +14891 # . eax: (addr var) = lookup(v) +14892 (lookup *ebx *(ebx+4)) # => eax +14893 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +14894 0f 84/jump-if-= $populate-mu-function-signature:error3/disp32 +14895 # if (var->name != "_") abort +14896 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14897 (string-equal? %eax "_") # => eax +14898 3d/compare-eax-and 0/imm32/false +14899 0f 84/jump-if-= $populate-mu-function-signature:error4/disp32 +14900 # if function name is not "lookup" +14901 # and v->type is an addr, abort +14902 { +14903 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14904 (string-equal? %eax "lookup") # => eax +14905 3d/compare-eax-and 0/imm32/false +14906 75/jump-if-!= break/disp8 +14907 (lookup *ebx *(ebx+4)) # => eax +14908 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +14909 (is-mu-addr-type? %eax) # => eax +14910 3d/compare-eax-and 0/imm32/false +14911 0f 85/jump-if-!= $populate-mu-function-signature:error-addr-output/disp32 +14912 } +14913 # out->outputs = append(v, out->outputs) +14914 8d/copy-address *(edi+0x10) 0/r32/eax # Function-outputs +14915 (append-list Heap *ebx *(ebx+4) *(edi+0x10) *(edi+0x14) %eax) # Function-outputs, Function-outputs +14916 # +14917 e9/jump loop/disp32 +14918 } +14919 $populate-mu-function-signature:done: +14920 (check-no-tokens-left *(ebp+8)) +14921 $populate-mu-function-signature:end: +14922 # . reclaim locals +14923 81 0/subop/add %esp 0x10/imm32 +14924 # . restore registers +14925 5f/pop-to-edi +14926 5b/pop-to-ebx +14927 5a/pop-to-edx +14928 59/pop-to-ecx +14929 58/pop-to-eax +14930 # . epilogue +14931 89/<- %esp 5/r32/ebp +14932 5d/pop-to-ebp +14933 c3/return +14934 +14935 $populate-mu-function-signature:error1: +14936 # error("function signature not in form 'fn <name> {'") +14937 (write-buffered *(ebp+0x10) "function signature not in form 'fn <name> [inouts] [-> outputs] {' -- '") +14938 (flush *(ebp+0x10)) +14939 (rewind-stream *(ebp+8)) +14940 (write-stream-data *(ebp+0x10) *(ebp+8)) +14941 (write-buffered *(ebp+0x10) "'\n") +14942 (flush *(ebp+0x10)) +14943 (stop *(ebp+0x14) 1) +14944 # never gets here +14945 +14946 $populate-mu-function-signature:error2: +14947 # error("fn " fn ": function inout '" var "' cannot be in a register") +14948 (write-buffered *(ebp+0x10) "fn ") +14949 50/push-eax +14950 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14951 (write-buffered *(ebp+0x10) %eax) +14952 58/pop-to-eax +14953 (write-buffered *(ebp+0x10) ": function inout '") +14954 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14955 (write-buffered *(ebp+0x10) %eax) +14956 (write-buffered *(ebp+0x10) "' cannot be in a register") +14957 (flush *(ebp+0x10)) +14958 (stop *(ebp+0x14) 1) +14959 # never gets here +14960 +14961 $populate-mu-function-signature:error3: +14962 # error("fn " fn ": function output '" var "' must be in a register") +14963 (write-buffered *(ebp+0x10) "fn ") +14964 50/push-eax +14965 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14966 (write-buffered *(ebp+0x10) %eax) +14967 58/pop-to-eax +14968 (write-buffered *(ebp+0x10) ": function output '") +14969 (lookup *ebx *(ebx+4)) # => eax +14970 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14971 (write-buffered *(ebp+0x10) %eax) +14972 (write-buffered *(ebp+0x10) "' must be in a register, in instruction '") +14973 (rewind-stream *(ebp+8)) +14974 (write-stream-data *(ebp+0x10) *(ebp+8)) +14975 (write-buffered *(ebp+0x10) "'\n") +14976 (flush *(ebp+0x10)) +14977 (stop *(ebp+0x14) 1) +14978 # never gets here +14979 +14980 $populate-mu-function-signature:error4: +14981 # error("fn " fn ": function outputs cannot be named; rename '" var "' in the header to '_'") +14982 (write-buffered *(ebp+0x10) "fn ") +14983 50/push-eax +14984 (lookup *edi *(edi+4)) # Function-name Function-name => eax +14985 (write-buffered *(ebp+0x10) %eax) +14986 58/pop-to-eax +14987 (write-buffered *(ebp+0x10) ": function outputs cannot be named; rename '") +14988 (lookup *ebx *(ebx+4)) # => eax +14989 (lookup *eax *(eax+4)) # Var-name Var-name => eax +14990 (write-buffered *(ebp+0x10) %eax) +14991 (write-buffered *(ebp+0x10) "' in the header to '_'\n") +14992 (flush *(ebp+0x10)) +14993 (stop *(ebp+0x14) 1) +14994 # never gets here +14995 +14996 $populate-mu-function-signature:error-duplicate: +14997 (write-buffered *(ebp+0x10) "fn ") +14998 (write-slice-buffered *(ebp+0x10) %ecx) +14999 (write-buffered *(ebp+0x10) " defined more than once\n") +15000 (flush *(ebp+0x10)) +15001 (stop *(ebp+0x14) 1) +15002 # never gets here +15003 +15004 $populate-mu-function-signature:error-break: +15005 (write-buffered *(ebp+0x10) "Sorry, I've reserved all function names starting with 'break' for now. Please contact mu@akkartik.com.\n") +15006 (flush *(ebp+0x10)) +15007 (stop *(ebp+0x14) 1) +15008 # never gets here +15009 +15010 $populate-mu-function-signature:error-loop: +15011 (write-buffered *(ebp+0x10) "Sorry, I've reserved all function names starting with 'loop' for now. Please contact mu@akkartik.com.\n") +15012 (flush *(ebp+0x10)) +15013 (stop *(ebp+0x14) 1) +15014 # never gets here +15015 +15016 $populate-mu-function-signature:error-addr-output: +15017 # error("fn " fn ": output cannot have an addr type; that could allow unsafe addresses to escape the function") +15018 (write-buffered *(ebp+0x10) "fn ") +15019 50/push-eax +15020 (lookup *edi *(edi+4)) # Function-name Function-name => eax +15021 (write-buffered *(ebp+0x10) %eax) +15022 58/pop-to-eax +15023 (write-buffered *(ebp+0x10) ": output cannot have an addr type; that could allow unsafe addresses to escape the function\n") +15024 (flush *(ebp+0x10)) +15025 (stop *(ebp+0x14) 1) +15026 # never gets here +15027 +15028 $populate-mu-function-signature:error-nested-addr-inout: +15029 # error("fn " fn ": inout '" var "' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function") +15030 (write-buffered *(ebp+0x10) "fn ") +15031 (lookup *edi *(edi+4)) # Function-name Function-name => eax +15032 (write-buffered *(ebp+0x10) %eax) +15033 (write-buffered *(ebp+0x10) ": inout '") +15034 (lookup *ebx *(ebx+4)) # => eax +15035 (lookup *eax *(eax+4)) # Var-name Var-name => eax +15036 (write-buffered *(ebp+0x10) %eax) +15037 (write-buffered *(ebp+0x10) "' cannot contain 'addr' anywhere in the type except the first word; that could allow unsafe addresses to escape the function\n") +15038 (flush *(ebp+0x10)) +15039 (stop *(ebp+0x14) 1) +15040 # never gets here +15041 +15042 addr-payload-contains-addr?: # v: (addr var) -> result/eax: boolean +15043 # . prologue +15044 55/push-ebp +15045 89/<- %ebp 4/r32/esp +15046 # var t/eax: (addr type-tree) = v->type +15047 8b/-> *(ebp+8) 0/r32/eax +15048 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +15049 # if t->right contains addr, return true +15050 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15051 (type-tree-contains? %eax 2) # addr => eax +15052 # we don't have to look at t->left as long as it's guaranteed to be an atom +15053 $addr-payload-contains-addr?:end: +15054 # . epilogue +15055 89/<- %esp 5/r32/ebp +15056 5d/pop-to-ebp +15057 c3/return +15058 +15059 type-tree-contains?: # t: (addr type-tree), n: type-id -> result/eax: boolean +15060 # . prologue +15061 55/push-ebp +15062 89/<- %ebp 4/r32/esp +15063 # . save registers +15064 51/push-ecx +15065 # if t is null, return false +15066 8b/-> *(ebp+8) 0/r32/eax +15067 3d/compare-eax-and 0/imm32 +15068 0f 84/jump-if-= $type-tree-contains?:end/disp32 # eax changes type +15069 # if t is an atom, return (t->value == n) +15070 81 7/subop/compare *eax 0/imm32/false +15071 { +15072 74/jump-if-= break/disp8 +15073 8b/-> *(ebp+0xc) 1/r32/ecx +15074 39/compare *(eax+4) 1/r32/ecx # Type-tree-value +15075 0f 94/set-if-= %al +15076 81 4/subop/and %eax 0xff/imm32 +15077 eb/jump $type-tree-contains?:end/disp8 +15078 } +15079 # if t->left contains n, return true +15080 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +15081 (type-tree-contains? %eax *(ebp+0xc)) # => eax +15082 3d/compare-eax-and 0/imm32/false +15083 75/jump-if-!= $type-tree-contains?:end/disp8 +15084 # otherwise return whether t->right contains n +15085 8b/-> *(ebp+8) 0/r32/eax +15086 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +15087 (type-tree-contains? %eax *(ebp+0xc)) # => eax +15088 $type-tree-contains?:end: +15089 # . restore registers +15090 59/pop-to-ecx +15091 # . epilogue +15092 89/<- %esp 5/r32/ebp +15093 5d/pop-to-ebp +15094 c3/return +15095 +15096 function-exists?: # s: (addr slice) -> result/eax: boolean +15097 # . prologue +15098 55/push-ebp +15099 89/<- %ebp 4/r32/esp +15100 # . save registers +15101 51/push-ecx +15102 # var curr/ecx: (addr function) = functions +15103 (lookup *_Program-functions *_Program-functions->payload) # => eax +15104 89/<- %ecx 0/r32/eax +15105 { +15106 # if (curr == null) break +15107 81 7/subop/compare %ecx 0/imm32 +15108 74/jump-if-= break/disp8 +15109 # if (curr->name == s) return true +15110 { +15111 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax +15112 (slice-equal? *(ebp+8) %eax) # => eax +15113 3d/compare-eax-and 0/imm32/false +15114 74/jump-if-= break/disp8 +15115 b8/copy-to-eax 1/imm32/true +15116 e9/jump $function-exists?:end/disp32 +15117 } +15118 # curr = curr->next +15119 (lookup *(ecx+0x20) *(ecx+0x24)) # Function-next Function-next => eax +15120 89/<- %ecx 0/r32/eax +15121 # +15122 eb/jump loop/disp8 +15123 } +15124 # var curr/ecx: (addr function) = signatures +15125 (lookup *_Program-signatures *_Program-signatures->payload) # => eax +15126 89/<- %ecx 0/r32/eax +15127 { +15128 # if (curr == null) break +15129 81 7/subop/compare %ecx 0/imm32 +15130 74/jump-if-= break/disp8 +15131 # if (curr->name == s) return true +15132 { +15133 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax +15134 (slice-equal? *(ebp+8) %eax) # => eax +15135 3d/compare-eax-and 0/imm32/false +15136 74/jump-if-= break/disp8 +15137 b8/copy-to-eax 1/imm32/true +15138 eb/jump $function-exists?:end/disp8 +15139 } +15140 # curr = curr->next +15141 (lookup *(ecx+0x20) *(ecx+0x24)) # Function-next Function-next => eax +15142 89/<- %ecx 0/r32/eax +15143 # +15144 eb/jump loop/disp8 +15145 } +15146 # return false +15147 b8/copy-to-eax 0/imm32/false +15148 $function-exists?:end: +15149 # . restore registers +15150 59/pop-to-ecx +15151 # . epilogue +15152 89/<- %esp 5/r32/ebp +15153 5d/pop-to-ebp +15154 c3/return +15155 +15156 test-function-header-with-arg: +15157 # . prologue +15158 55/push-ebp +15159 89/<- %ebp 4/r32/esp +15160 # setup +15161 8b/-> *Primitive-type-ids 0/r32/eax +15162 89/<- *Type-id 0/r32/eax # stream-write +15163 c7 0/subop/copy *_Program-functions 0/imm32 +15164 c7 0/subop/copy *_Program-functions->payload 0/imm32 +15165 c7 0/subop/copy *_Program-types 0/imm32 +15166 c7 0/subop/copy *_Program-types->payload 0/imm32 +15167 c7 0/subop/copy *_Program-signatures 0/imm32 +15168 c7 0/subop/copy *_Program-signatures->payload 0/imm32 +15169 (clear-stream _test-input-stream) +15170 (write _test-input-stream "foo n: int {\n") +15171 # var result/ecx: function +15172 2b/subtract *Function-size 4/r32/esp +15173 89/<- %ecx 4/r32/esp +15174 (zero-out %ecx *Function-size) +15175 # var vars/ebx: (stack live-var 16) +15176 81 5/subop/subtract %esp 0xc0/imm32 +15177 68/push 0xc0/imm32/size +15178 68/push 0/imm32/top +15179 89/<- %ebx 4/r32/esp +15180 # convert +15181 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) +15182 # check result->name +15183 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax +15184 (check-strings-equal %eax "foo" "F - test-function-header-with-arg/name") +15185 # var v/edx: (addr var) = result->inouts->value +15186 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax +15187 (lookup *eax *(eax+4)) # List-value List-value => eax +15188 89/<- %edx 0/r32/eax +15189 # check v->name +15190 (lookup *edx *(edx+4)) # Var-name Var-name => eax +15191 (check-strings-equal %eax "n" "F - test-function-header-with-arg/inout:0") +15192 # check v->type +15193 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +15194 (check-ints-equal *eax 1 "F - test-function-header-with-arg/inout:0/type:0") # Type-tree-is-atom +15195 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-arg/inout:0/type:1") # Type-tree-value +15196 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-arg/inout:0/type:2") # Type-tree-right +15197 # . epilogue +15198 89/<- %esp 5/r32/ebp +15199 5d/pop-to-ebp +15200 c3/return +15201 +15202 test-function-header-with-multiple-args: +15203 # . prologue +15204 55/push-ebp +15205 89/<- %ebp 4/r32/esp +15206 # setup +15207 8b/-> *Primitive-type-ids 0/r32/eax +15208 89/<- *Type-id 0/r32/eax # stream-write +15209 c7 0/subop/copy *_Program-functions 0/imm32 +15210 c7 0/subop/copy *_Program-functions->payload 0/imm32 +15211 c7 0/subop/copy *_Program-types 0/imm32 +15212 c7 0/subop/copy *_Program-types->payload 0/imm32 +15213 c7 0/subop/copy *_Program-signatures 0/imm32 +15214 c7 0/subop/copy *_Program-signatures->payload 0/imm32 15215 (clear-stream _test-input-stream) -15216 (write _test-input-stream "int") -15217 # var v/edx: (handle var) -15218 68/push 0/imm32 -15219 68/push 0/imm32 -15220 89/<- %edx 4/r32/esp -15221 # -15222 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) -15223 # var v-addr/edx: (addr var) = lookup(v) -15224 (lookup *edx *(edx+4)) # => eax -15225 89/<- %edx 0/r32/eax -15226 # check v-addr->name -15227 (lookup *edx *(edx+4)) # Var-name Var-name => eax -15228 (check-strings-equal %eax "x" "F - test-parse-var-with-type/name") -15229 # check v-addr->type -15230 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15231 (check-ints-equal *eax 1 "F - test-parse-var-with-type/type:0") # Type-tree-is-atom -15232 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type/type:1") # Type-tree-value -15233 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type/type:2") # Type-tree-right -15234 # . epilogue -15235 89/<- %esp 5/r32/ebp -15236 5d/pop-to-ebp -15237 c3/return -15238 -15239 test-parse-var-with-type-and-register: -15240 # . prologue -15241 55/push-ebp -15242 89/<- %ebp 4/r32/esp -15243 # setup -15244 8b/-> *Primitive-type-ids 0/r32/eax -15245 89/<- *Type-id 0/r32/eax # stream-write -15246 # (eax..ecx) = "x/eax:" -15247 b8/copy-to-eax "x/eax:"/imm32 -15248 8b/-> *eax 1/r32/ecx -15249 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15250 05/add-to-eax 4/imm32 -15251 # var slice/ecx: slice = {eax, ecx} -15252 51/push-ecx -15253 50/push-eax -15254 89/<- %ecx 4/r32/esp -15255 # _test-input-stream contains "int" -15256 (clear-stream _test-input-stream) -15257 (write _test-input-stream "int") -15258 # var v/edx: (handle var) -15259 68/push 0/imm32 -15260 68/push 0/imm32 -15261 89/<- %edx 4/r32/esp -15262 # -15263 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) -15264 # var v-addr/edx: (addr var) = lookup(v) -15265 (lookup *edx *(edx+4)) # => eax -15266 89/<- %edx 0/r32/eax -15267 # check v-addr->name -15268 (lookup *edx *(edx+4)) # Var-name Var-name => eax -15269 (check-strings-equal %eax "x" "F - test-parse-var-with-type-and-register/name") -15270 # check v-addr->register -15271 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -15272 (check-strings-equal %eax "eax" "F - test-parse-var-with-type-and-register/register") -15273 # check v-addr->type -15274 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15275 (check-ints-equal *eax 1 "F - test-parse-var-with-type-and-register/type:0") # Type-tree-is-atom -15276 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type-and-register/type:1") # Type-tree-left -15277 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type-and-register/type:2") # Type-tree-right -15278 # . epilogue -15279 89/<- %esp 5/r32/ebp -15280 5d/pop-to-ebp -15281 c3/return -15282 -15283 test-parse-var-with-trailing-characters: -15284 # . prologue -15285 55/push-ebp -15286 89/<- %ebp 4/r32/esp -15287 # setup -15288 8b/-> *Primitive-type-ids 0/r32/eax -15289 89/<- *Type-id 0/r32/eax # stream-write -15290 # (eax..ecx) = "x:" -15291 b8/copy-to-eax "x:"/imm32 -15292 8b/-> *eax 1/r32/ecx -15293 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15294 05/add-to-eax 4/imm32 -15295 # var slice/ecx: slice = {eax, ecx} -15296 51/push-ecx -15297 50/push-eax +15216 (write _test-input-stream "foo a: int, b: int c: int {\n") +15217 # result/ecx: function +15218 2b/subtract *Function-size 4/r32/esp +15219 89/<- %ecx 4/r32/esp +15220 (zero-out %ecx *Function-size) +15221 # var vars/ebx: (stack live-var 16) +15222 81 5/subop/subtract %esp 0xc0/imm32 +15223 68/push 0xc0/imm32/size +15224 68/push 0/imm32/top +15225 89/<- %ebx 4/r32/esp +15226 # convert +15227 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) +15228 # check result->name +15229 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax +15230 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args/name") +15231 # var inouts/edx: (addr list var) = lookup(result->inouts) +15232 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax +15233 89/<- %edx 0/r32/eax +15234 $test-function-header-with-multiple-args:inout0: +15235 # var v/ebx: (addr var) = lookup(inouts->value) +15236 (lookup *edx *(edx+4)) # List-value List-value => eax +15237 89/<- %ebx 0/r32/eax +15238 # check v->name +15239 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +15240 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args/inout:0") # Var-name +15241 # check v->type +15242 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax +15243 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:0/type:0") # Type-tree-is-atom +15244 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:0/type:1") # Type-tree-value +15245 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:0/type:2") # Type-tree-right +15246 $test-function-header-with-multiple-args:inout1: +15247 # inouts = lookup(inouts->next) +15248 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax +15249 89/<- %edx 0/r32/eax +15250 # v = lookup(inouts->value) +15251 (lookup *edx *(edx+4)) # List-value List-value => eax +15252 89/<- %ebx 0/r32/eax +15253 # check v->name +15254 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +15255 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args/inout:1") # Var-name +15256 # check v->type +15257 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax +15258 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:1/type:0") # Type-tree-is-atom +15259 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:1/type:1") # Type-tree-value +15260 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:1/type:2") # Type-tree-right +15261 $test-function-header-with-multiple-args:inout2: +15262 # inouts = lookup(inouts->next) +15263 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax +15264 89/<- %edx 0/r32/eax +15265 # v = lookup(inouts->value) +15266 (lookup *edx *(edx+4)) # List-value List-value => eax +15267 89/<- %ebx 0/r32/eax +15268 # check v->name +15269 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +15270 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args/inout:2") # Var-name +15271 # check v->type +15272 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax +15273 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args/inout:2/type:0") # Type-tree-is-atom +15274 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args/inout:2/type:1") # Type-tree-value +15275 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args/inout:2/type:2") # Type-tree-right +15276 # . epilogue +15277 89/<- %esp 5/r32/ebp +15278 5d/pop-to-ebp +15279 c3/return +15280 +15281 test-function-header-with-multiple-args-and-outputs: +15282 # . prologue +15283 55/push-ebp +15284 89/<- %ebp 4/r32/esp +15285 # setup +15286 8b/-> *Primitive-type-ids 0/r32/eax +15287 89/<- *Type-id 0/r32/eax # stream-write +15288 c7 0/subop/copy *_Program-functions 0/imm32 +15289 c7 0/subop/copy *_Program-functions->payload 0/imm32 +15290 c7 0/subop/copy *_Program-types 0/imm32 +15291 c7 0/subop/copy *_Program-types->payload 0/imm32 +15292 c7 0/subop/copy *_Program-signatures 0/imm32 +15293 c7 0/subop/copy *_Program-signatures->payload 0/imm32 +15294 (clear-stream _test-input-stream) +15295 (write _test-input-stream "foo a: int, b: int, c: int -> _/ecx: int _/edx: int {\n") +15296 # result/ecx: function +15297 2b/subtract *Function-size 4/r32/esp 15298 89/<- %ecx 4/r32/esp -15299 # _test-input-stream contains "int," -15300 (clear-stream _test-input-stream) -15301 (write _test-input-stream "int,") -15302 # var v/edx: (handle var) -15303 68/push 0/imm32 -15304 68/push 0/imm32 -15305 89/<- %edx 4/r32/esp -15306 # -15307 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) -15308 # var v-addr/edx: (addr var) = lookup(v) -15309 (lookup *edx *(edx+4)) # => eax -15310 89/<- %edx 0/r32/eax -15311 # check v-addr->name -15312 (lookup *edx *(edx+4)) # Var-name Var-name => eax -15313 (check-strings-equal %eax "x" "F - test-parse-var-with-trailing-characters/name") -15314 # check v-addr->register -15315 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-trailing-characters/register") # Var-register -15316 # check v-addr->type -15317 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15318 (check-ints-equal *eax 1 "F - test-parse-var-with-trailing-characters/type:0") # Type-tree-is-atom -15319 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-trailing-characters/type:1") # Type-tree-left -15320 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-trailing-characters/type:1") # Type-tree-right -15321 # . epilogue -15322 89/<- %esp 5/r32/ebp -15323 5d/pop-to-ebp -15324 c3/return -15325 -15326 test-parse-var-with-register-and-trailing-characters: -15327 # . prologue -15328 55/push-ebp -15329 89/<- %ebp 4/r32/esp -15330 # setup -15331 8b/-> *Primitive-type-ids 0/r32/eax -15332 89/<- *Type-id 0/r32/eax # stream-write -15333 # (eax..ecx) = "x/eax:" -15334 b8/copy-to-eax "x/eax:"/imm32 -15335 8b/-> *eax 1/r32/ecx -15336 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15337 05/add-to-eax 4/imm32 -15338 # var slice/ecx: slice = {eax, ecx} -15339 51/push-ecx -15340 50/push-eax -15341 89/<- %ecx 4/r32/esp -15342 # _test-input-stream contains "int," -15343 (clear-stream _test-input-stream) -15344 (write _test-input-stream "int,") -15345 # var v/edx: (handle var) -15346 68/push 0/imm32 -15347 68/push 0/imm32 -15348 89/<- %edx 4/r32/esp -15349 # -15350 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) -15351 # var v-addr/edx: (addr var) = lookup(v) -15352 (lookup *edx *(edx+4)) # => eax -15353 89/<- %edx 0/r32/eax -15354 # check v-addr->name -15355 (lookup *edx *(edx+4)) # Var-name Var-name => eax -15356 (check-strings-equal %eax "x" "F - test-parse-var-with-register-and-trailing-characters/name") -15357 # check v-addr->register -15358 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -15359 (check-strings-equal %eax "eax" "F - test-parse-var-with-register-and-trailing-characters/register") -15360 # check v-addr->type -15361 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15362 (check-ints-equal *eax 1 "F - test-parse-var-with-register-and-trailing-characters/type:0") # Type-tree-is-atom -15363 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-register-and-trailing-characters/type:1") # Type-tree-left -15364 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-register-and-trailing-characters/type:2") # Type-tree-right -15365 # . epilogue -15366 89/<- %esp 5/r32/ebp -15367 5d/pop-to-ebp -15368 c3/return -15369 -15370 test-parse-var-with-compound-type: -15371 # . prologue -15372 55/push-ebp -15373 89/<- %ebp 4/r32/esp -15374 # setup -15375 8b/-> *Primitive-type-ids 0/r32/eax -15376 89/<- *Type-id 0/r32/eax # stream-write -15377 # (eax..ecx) = "x:" -15378 b8/copy-to-eax "x:"/imm32 -15379 8b/-> *eax 1/r32/ecx -15380 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15381 05/add-to-eax 4/imm32 -15382 # var slice/ecx: slice = {eax, ecx} -15383 51/push-ecx -15384 50/push-eax -15385 89/<- %ecx 4/r32/esp -15386 # _test-input-stream contains "(addr int)" -15387 (clear-stream _test-input-stream) -15388 (write _test-input-stream "(addr int)") -15389 # var v/edx: (handle var) -15390 68/push 0/imm32 -15391 68/push 0/imm32 -15392 89/<- %edx 4/r32/esp -15393 # -15394 (parse-var-with-type %ecx _test-input-stream %edx Stderr 0) -15395 # var v-addr/edx: (addr var) = lookup(v) -15396 (lookup *edx *(edx+4)) # => eax -15397 89/<- %edx 0/r32/eax -15398 # check v-addr->name -15399 (lookup *edx *(edx+4)) # Var-name Var-name => eax -15400 (check-strings-equal %eax "x" "F - test-parse-var-with-compound-type/name") -15401 # check v-addr->register -15402 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-compound-type/register") # Var-register -15403 # - check v-addr->type -15404 # var type/edx: (addr type-tree) = var->type -15405 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -15406 89/<- %edx 0/r32/eax -15407 # type is a non-atom -15408 (check-ints-equal *edx 0 "F - test-parse-var-with-compound-type/type:0") # Type-tree-is-atom -15409 # type->left == atom(addr) -15410 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -15411 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:1") # Type-tree-is-atom -15412 (check-ints-equal *(eax+4) 2 "F - test-parse-var-with-compound-type/type:2") # Type-tree-value -15413 # type->right->left == atom(int) -15414 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax -15415 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -15416 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:3") # Type-tree-is-atom -15417 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-compound-type/type:4") # Type-tree-value -15418 # type->right->right == null -15419 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-compound-type/type:5") # Type-tree-right -15420 # . epilogue -15421 89/<- %esp 5/r32/ebp -15422 5d/pop-to-ebp -15423 c3/return -15424 -15425 # identifier starts with a letter or '$' or '_' -15426 # no constraints at the moment on later letters -15427 # all we really want to do so far is exclude '{', '}' and '->' -15428 is-identifier?: # in: (addr slice) -> result/eax: boolean -15429 # . prologue -15430 55/push-ebp -15431 89/<- %ebp 4/r32/esp -15432 # if (slice-empty?(in)) return false -15433 (slice-empty? *(ebp+8)) # => eax -15434 3d/compare-eax-and 0/imm32/false -15435 75/jump-if-!= $is-identifier?:false/disp8 -15436 # var c/eax: byte = *in->start -15437 8b/-> *(ebp+8) 0/r32/eax -15438 8b/-> *eax 0/r32/eax -15439 8a/copy-byte *eax 0/r32/AL -15440 81 4/subop/and %eax 0xff/imm32 -15441 # if (c == '$') return true -15442 3d/compare-eax-and 0x24/imm32/$ -15443 74/jump-if-= $is-identifier?:true/disp8 -15444 # if (c == '_') return true -15445 3d/compare-eax-and 0x5f/imm32/_ -15446 74/jump-if-= $is-identifier?:true/disp8 -15447 # drop case -15448 25/and-eax-with 0x5f/imm32 -15449 # if (c < 'A') return false -15450 3d/compare-eax-and 0x41/imm32/A -15451 7c/jump-if-< $is-identifier?:false/disp8 -15452 # if (c > 'Z') return false -15453 3d/compare-eax-and 0x5a/imm32/Z -15454 7f/jump-if-> $is-identifier?:false/disp8 -15455 # otherwise return true -15456 $is-identifier?:true: -15457 b8/copy-to-eax 1/imm32/true -15458 eb/jump $is-identifier?:end/disp8 -15459 $is-identifier?:false: -15460 b8/copy-to-eax 0/imm32/false -15461 $is-identifier?:end: -15462 # . epilogue -15463 89/<- %esp 5/r32/ebp -15464 5d/pop-to-ebp -15465 c3/return -15466 -15467 test-is-identifier-dollar: -15468 # . prologue -15469 55/push-ebp -15470 89/<- %ebp 4/r32/esp -15471 # (eax..ecx) = "$a" -15472 b8/copy-to-eax "$a"/imm32 -15473 8b/-> *eax 1/r32/ecx -15474 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15475 05/add-to-eax 4/imm32 -15476 # var slice/ecx: slice = {eax, ecx} -15477 51/push-ecx -15478 50/push-eax -15479 89/<- %ecx 4/r32/esp -15480 # -15481 (is-identifier? %ecx) -15482 (check-ints-equal %eax 1 "F - test-is-identifier-dollar") -15483 # . epilogue -15484 89/<- %esp 5/r32/ebp -15485 5d/pop-to-ebp -15486 c3/return -15487 -15488 test-is-identifier-underscore: -15489 # . prologue -15490 55/push-ebp -15491 89/<- %ebp 4/r32/esp -15492 # (eax..ecx) = "_a" -15493 b8/copy-to-eax "_a"/imm32 -15494 8b/-> *eax 1/r32/ecx -15495 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15496 05/add-to-eax 4/imm32 -15497 # var slice/ecx: slice = {eax, ecx} -15498 51/push-ecx -15499 50/push-eax -15500 89/<- %ecx 4/r32/esp -15501 # -15502 (is-identifier? %ecx) -15503 (check-ints-equal %eax 1 "F - test-is-identifier-underscore") -15504 # . epilogue -15505 89/<- %esp 5/r32/ebp -15506 5d/pop-to-ebp -15507 c3/return -15508 -15509 test-is-identifier-a: -15510 # . prologue -15511 55/push-ebp -15512 89/<- %ebp 4/r32/esp -15513 # (eax..ecx) = "a$" -15514 b8/copy-to-eax "a$"/imm32 -15515 8b/-> *eax 1/r32/ecx -15516 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15517 05/add-to-eax 4/imm32 -15518 # var slice/ecx: slice = {eax, ecx} -15519 51/push-ecx -15520 50/push-eax -15521 89/<- %ecx 4/r32/esp -15522 # -15523 (is-identifier? %ecx) -15524 (check-ints-equal %eax 1 "F - test-is-identifier-a") -15525 # . epilogue -15526 89/<- %esp 5/r32/ebp -15527 5d/pop-to-ebp -15528 c3/return +15299 (zero-out %ecx *Function-size) +15300 # var vars/ebx: (stack live-var 16) +15301 81 5/subop/subtract %esp 0xc0/imm32 +15302 68/push 0xc0/imm32/size +15303 68/push 0/imm32/top +15304 89/<- %ebx 4/r32/esp +15305 # convert +15306 (populate-mu-function-header _test-input-stream %ecx %ebx Stderr 0) +15307 # check result->name +15308 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax +15309 (check-strings-equal %eax "foo" "F - test-function-header-with-multiple-args-and-outputs/name") +15310 # var inouts/edx: (addr list var) = lookup(result->inouts) +15311 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax +15312 89/<- %edx 0/r32/eax +15313 $test-function-header-with-multiple-args-and-outputs:inout0: +15314 # var v/ebx: (addr var) = lookup(inouts->value) +15315 (lookup *edx *(edx+4)) # List-value List-value => eax +15316 89/<- %ebx 0/r32/eax +15317 # check v->name +15318 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +15319 (check-strings-equal %eax "a" "F - test-function-header-with-multiple-args-and-outputs/inout:0") +15320 # check v->type +15321 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax +15322 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:0") # Type-tree-is-atom +15323 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:1") # Type-tree-value +15324 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:0/type:2") # Type-tree-right +15325 $test-function-header-with-multiple-args-and-outputs:inout1: +15326 # inouts = lookup(inouts->next) +15327 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax +15328 89/<- %edx 0/r32/eax +15329 # v = lookup(inouts->value) +15330 (lookup *edx *(edx+4)) # List-value List-value => eax +15331 89/<- %ebx 0/r32/eax +15332 # check v->name +15333 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +15334 (check-strings-equal %eax "b" "F - test-function-header-with-multiple-args-and-outputs/inout:1") +15335 # check v->type +15336 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax +15337 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:0") # Type-tree-is-atom +15338 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:1") # Type-tree-value +15339 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:1/type:2") # Type-tree-right +15340 $test-function-header-with-multiple-args-and-outputs:inout2: +15341 # inouts = lookup(inouts->next) +15342 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax +15343 89/<- %edx 0/r32/eax +15344 # v = lookup(inouts->value) +15345 (lookup *edx *(edx+4)) # List-value List-value => eax +15346 89/<- %ebx 0/r32/eax +15347 # check v->name +15348 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +15349 (check-strings-equal %eax "c" "F - test-function-header-with-multiple-args-and-outputs/inout:2") +15350 # check v->type +15351 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax +15352 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:0") # Type-tree-is-atom +15353 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:1") # Type-tree-value +15354 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/inout:2/type:2") # Type-tree-right +15355 $test-function-header-with-multiple-args-and-outputs:out0: +15356 # var outputs/edx: (addr list var) = lookup(result->outputs) +15357 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax +15358 89/<- %edx 0/r32/eax +15359 # v = lookup(outputs->value) +15360 (lookup *edx *(edx+4)) # List-value List-value => eax +15361 89/<- %ebx 0/r32/eax +15362 # check v->name +15363 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +15364 (check-strings-equal %eax "_" "F - test-function-header-with-multiple-args-and-outputs/output:0") +15365 # check v->register +15366 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +15367 (check-strings-equal %eax "ecx" "F - test-function-header-with-multiple-args-and-outputs/output:0/register") +15368 # check v->type +15369 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax +15370 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:0") # Type-tree-is-atom +15371 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:1") # Type-tree-value +15372 (check-ints-equal *(eax+0xc) 0 "F - test-function-header-with-multiple-args-and-outputs/output:0/type:2") # Type-tree-right +15373 $test-function-header-with-multiple-args-and-outputs:out1: +15374 # outputs = lookup(outputs->next) +15375 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax +15376 89/<- %edx 0/r32/eax +15377 # v = lookup(inouts->value) +15378 (lookup *edx *(edx+4)) # List-value List-value => eax +15379 89/<- %ebx 0/r32/eax +15380 # check v->name +15381 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +15382 (check-strings-equal %eax "_" "F - test-function-header-with-multiple-args-and-outputs/output:1") +15383 # check v->register +15384 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +15385 (check-strings-equal %eax "edx" "F - test-function-header-with-multiple-args-and-outputs/output:1/register") +15386 # check v->type +15387 (lookup *(ebx+8) *(ebx+0xc)) # Var-type Var-type => eax +15388 (check-ints-equal *eax 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:0") # Type-tree-is-atom +15389 (check-ints-equal *(eax+4) 1 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:1") # Type-tree-value +15390 (check-ints-equal *(eax+0c) 0 "F - test-function-header-with-multiple-args-and-outputs/output:1/type:2") # Type-tree-right +15391 # . epilogue +15392 89/<- %esp 5/r32/ebp +15393 5d/pop-to-ebp +15394 c3/return +15395 +15396 # format for variables with types +15397 # x: int +15398 # x: int, +15399 # x/eax: int +15400 # x/eax: int, +15401 # ignores at most one trailing comma +15402 # WARNING: modifies name +15403 parse-var-with-type: # name: (addr slice), first-line: (addr stream byte), out: (addr handle var), fn-name: (addr array byte), err: (addr buffered-file), ed: (addr exit-descriptor) +15404 # pseudocode: +15405 # var s: slice +15406 # if (!slice-ends-with(name, ":")) +15407 # abort +15408 # --name->end to skip ':' +15409 # next-token-from-slice(name->start, name->end, '/', s) +15410 # new-var-from-slice(s, out) +15411 # ## register +15412 # next-token-from-slice(s->end, name->end, '/', s) +15413 # if (!slice-empty?(s)) +15414 # out->register = slice-to-string(s) +15415 # ## type +15416 # var type: (handle type-tree) = parse-type(first-line) +15417 # out->type = type +15418 # +15419 # . prologue +15420 55/push-ebp +15421 89/<- %ebp 4/r32/esp +15422 # . save registers +15423 50/push-eax +15424 51/push-ecx +15425 52/push-edx +15426 53/push-ebx +15427 56/push-esi +15428 57/push-edi +15429 # esi = name +15430 8b/-> *(ebp+8) 6/r32/esi +15431 # if (!slice-ends-with?(name, ":")) abort +15432 8b/-> *(esi+4) 1/r32/ecx # Slice-end +15433 49/decrement-ecx +15434 8a/copy-byte *ecx 1/r32/CL +15435 81 4/subop/and %ecx 0xff/imm32 +15436 81 7/subop/compare %ecx 0x3a/imm32/colon +15437 0f 85/jump-if-!= $parse-var-with-type:abort/disp32 +15438 # --name->end to skip ':' +15439 ff 1/subop/decrement *(esi+4) +15440 # var s/ecx: slice +15441 68/push 0/imm32/end +15442 68/push 0/imm32/start +15443 89/<- %ecx 4/r32/esp +15444 $parse-var-with-type:parse-name: +15445 (next-token-from-slice *esi *(esi+4) 0x2f %ecx) # Slice-start, Slice-end, '/' +15446 $parse-var-with-type:create-var: +15447 # new-var-from-slice(s, out) +15448 (new-var-from-slice Heap %ecx *(ebp+0x10)) +15449 # save out->register +15450 $parse-var-with-type:save-register: +15451 # . var out-addr/edi: (addr var) = lookup(*out) +15452 8b/-> *(ebp+0x10) 7/r32/edi +15453 (lookup *edi *(edi+4)) # => eax +15454 89/<- %edi 0/r32/eax +15455 # . s = next-token(...) +15456 (next-token-from-slice *(ecx+4) *(esi+4) 0x2f %ecx) # s->end, name->end, '/' +15457 # . if (!slice-empty?(s)) out->register = slice-to-string(s) +15458 { +15459 $parse-var-with-type:write-register: +15460 (slice-empty? %ecx) # => eax +15461 3d/compare-eax-and 0/imm32/false +15462 75/jump-if-!= break/disp8 +15463 # out->register = slice-to-string(s) +15464 8d/copy-address *(edi+0x18) 0/r32/eax # Var-register +15465 (slice-to-string Heap %ecx %eax) +15466 } +15467 $parse-var-with-type:save-type: +15468 8d/copy-address *(edi+8) 0/r32/eax # Var-type +15469 (parse-type Heap *(ebp+0xc) %eax *(ebp+0x18) *(ebp+0x1c)) +15470 $parse-var-with-type:check-register: +15471 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax +15472 3d/compare-eax-and 0/imm32 +15473 74/jump-if-= $parse-var-with-type:end/disp8 +15474 (is-float-register? %eax) # => eax +15475 { +15476 3d/compare-eax-and 0/imm32/false +15477 74/jump-if-= break/disp8 +15478 # var is in a float register; ensure type is float +15479 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +15480 (is-simple-mu-type? %eax 0xf) # float => eax +15481 3d/compare-eax-and 0/imm32/false +15482 0f 84/jump-if-= $parse-var-with-type:error-non-float-in-floating-point-register/disp32 +15483 eb/jump $parse-var-with-type:end/disp8 +15484 } +15485 # var is not in a float register; ensure type is not float +15486 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +15487 (is-simple-mu-type? %eax 0xf) # float => eax +15488 3d/compare-eax-and 0/imm32/false +15489 0f 85/jump-if-!= $parse-var-with-type:error-float-in-integer-register/disp32 +15490 $parse-var-with-type:end: +15491 # . reclaim locals +15492 81 0/subop/add %esp 8/imm32 +15493 # . restore registers +15494 5f/pop-to-edi +15495 5e/pop-to-esi +15496 5b/pop-to-ebx +15497 5a/pop-to-edx +15498 59/pop-to-ecx +15499 58/pop-to-eax +15500 # . epilogue +15501 89/<- %esp 5/r32/ebp +15502 5d/pop-to-ebp +15503 c3/return +15504 +15505 $parse-var-with-type:abort: +15506 # error("fn " fn ": var should have form 'name: type' in '" line "'\n") +15507 (write-buffered *(ebp+0x18) "fn ") +15508 (write-buffered *(ebp+0x18) *(ebp+0x14)) +15509 (write-buffered *(ebp+0x18) ": var should have form 'name: type' in '") +15510 (flush *(ebp+0x18)) +15511 (rewind-stream *(ebp+0xc)) +15512 (write-stream-data *(ebp+0x18) *(ebp+0xc)) +15513 (write-buffered *(ebp+0x18) "'\n") +15514 (flush *(ebp+0x18)) +15515 (stop *(ebp+0x1c) 1) +15516 # never gets here +15517 +15518 $parse-var-with-type:error-float-in-integer-register: +15519 # error("fn " fn ": float var '" var "' should be in a floating-point register\n") +15520 (write-buffered *(ebp+0x18) "fn ") +15521 (write-buffered *(ebp+0x18) *(ebp+0x14)) +15522 (write-buffered *(ebp+0x18) ": float var '") +15523 (lookup *edi *(edi+4)) # Var-name Var-name => eax +15524 (write-buffered *(ebp+0x18) %eax) +15525 (write-buffered *(ebp+0x18) "' should be in a floating-point register\n") +15526 (flush *(ebp+0x18)) +15527 (stop *(ebp+0x1c) 1) +15528 # never gets here 15529 -15530 test-is-identifier-z: -15531 # . prologue -15532 55/push-ebp -15533 89/<- %ebp 4/r32/esp -15534 # (eax..ecx) = "z$" -15535 b8/copy-to-eax "z$"/imm32 -15536 8b/-> *eax 1/r32/ecx -15537 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15538 05/add-to-eax 4/imm32 -15539 # var slice/ecx: slice = {eax, ecx} -15540 51/push-ecx -15541 50/push-eax -15542 89/<- %ecx 4/r32/esp -15543 # -15544 (is-identifier? %ecx) -15545 (check-ints-equal %eax 1 "F - test-is-identifier-z") -15546 # . epilogue -15547 89/<- %esp 5/r32/ebp -15548 5d/pop-to-ebp -15549 c3/return -15550 -15551 test-is-identifier-A: -15552 # . prologue -15553 55/push-ebp -15554 89/<- %ebp 4/r32/esp -15555 # (eax..ecx) = "A$" -15556 b8/copy-to-eax "A$"/imm32 -15557 8b/-> *eax 1/r32/ecx -15558 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15559 05/add-to-eax 4/imm32 -15560 # var slice/ecx: slice = {eax, ecx} -15561 51/push-ecx -15562 50/push-eax -15563 89/<- %ecx 4/r32/esp -15564 # -15565 (is-identifier? %ecx) -15566 (check-ints-equal %eax 1 "F - test-is-identifier-A") -15567 # . epilogue -15568 89/<- %esp 5/r32/ebp -15569 5d/pop-to-ebp -15570 c3/return -15571 -15572 test-is-identifier-Z: -15573 # . prologue -15574 55/push-ebp -15575 89/<- %ebp 4/r32/esp -15576 # (eax..ecx) = "Z$" -15577 b8/copy-to-eax "Z$"/imm32 -15578 8b/-> *eax 1/r32/ecx -15579 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15580 05/add-to-eax 4/imm32 -15581 # var slice/ecx: slice = {eax, ecx} -15582 51/push-ecx +15530 $parse-var-with-type:error-non-float-in-floating-point-register: +15531 # error("fn " fn ": non-float var '" var "' should be in an integer register\n") +15532 (write-buffered *(ebp+0x18) "fn ") +15533 (write-buffered *(ebp+0x18) *(ebp+0x14)) +15534 (write-buffered *(ebp+0x18) ": non-float var '") +15535 (lookup *edi *(edi+4)) # Var-name Var-name => eax +15536 (write-buffered *(ebp+0x18) %eax) +15537 (write-buffered *(ebp+0x18) "' should be in an integer register\n") +15538 (flush *(ebp+0x18)) +15539 (stop *(ebp+0x1c) 1) +15540 # never gets here +15541 +15542 is-float-register?: # r: (addr array byte) -> result/eax: boolean +15543 # . prologue +15544 55/push-ebp +15545 89/<- %ebp 4/r32/esp +15546 # +15547 (get Mu-registers-unique *(ebp+8) 0xc "Mu-registers-unique") # => eax +15548 81 7/subop/compare *eax 8/imm32/start-of-floating-point-registers +15549 0f 9d/set-if->= %al +15550 81 4/subop/and %eax 0xff/imm32 +15551 $is-float-register?:end: +15552 # . epilogue +15553 89/<- %esp 5/r32/ebp +15554 5d/pop-to-ebp +15555 c3/return +15556 +15557 parse-type: # ad: (addr allocation-descriptor), in: (addr stream byte), out: (addr handle type-tree), err: (addr buffered-file), ed: (addr exit-descriptor) +15558 # pseudocode: +15559 # var s: slice = next-mu-token(in) +15560 # assert s != "" +15561 # assert s != "->" +15562 # assert s != "{" +15563 # assert s != "}" +15564 # if s == ")" +15565 # return +15566 # out = allocate(Type-tree) +15567 # if s != "(" +15568 # HACK: if s is an int, parse and return it +15569 # out->is-atom? = true +15570 # if (s[0] == "_") +15571 # out->value = type-parameter +15572 # out->parameter-name = slice-to-string(ad, s) +15573 # else +15574 # out->value = pos-or-insert-slice(Type-id, s) +15575 # return +15576 # out->left = parse-type(ad, in) +15577 # out->right = parse-type-tree(ad, in) +15578 # +15579 # . prologue +15580 55/push-ebp +15581 89/<- %ebp 4/r32/esp +15582 # . save registers 15583 50/push-eax -15584 89/<- %ecx 4/r32/esp -15585 # -15586 (is-identifier? %ecx) -15587 (check-ints-equal %eax 1 "F - test-is-identifier-Z") -15588 # . epilogue -15589 89/<- %esp 5/r32/ebp -15590 5d/pop-to-ebp -15591 c3/return -15592 -15593 test-is-identifier-at: -15594 # character before 'A' is invalid -15595 # . prologue -15596 55/push-ebp -15597 89/<- %ebp 4/r32/esp -15598 # (eax..ecx) = "@a" -15599 b8/copy-to-eax "@a"/imm32 -15600 8b/-> *eax 1/r32/ecx -15601 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15602 05/add-to-eax 4/imm32 -15603 # var slice/ecx: slice = {eax, ecx} -15604 51/push-ecx -15605 50/push-eax -15606 89/<- %ecx 4/r32/esp -15607 # -15608 (is-identifier? %ecx) -15609 (check-ints-equal %eax 0 "F - test-is-identifier-@") -15610 # . epilogue -15611 89/<- %esp 5/r32/ebp -15612 5d/pop-to-ebp -15613 c3/return -15614 -15615 test-is-identifier-square-bracket: -15616 # character after 'Z' is invalid -15617 # . prologue -15618 55/push-ebp -15619 89/<- %ebp 4/r32/esp -15620 # (eax..ecx) = "[a" -15621 b8/copy-to-eax "[a"/imm32 -15622 8b/-> *eax 1/r32/ecx -15623 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15624 05/add-to-eax 4/imm32 -15625 # var slice/ecx: slice = {eax, ecx} -15626 51/push-ecx -15627 50/push-eax -15628 89/<- %ecx 4/r32/esp -15629 # -15630 (is-identifier? %ecx) -15631 (check-ints-equal %eax 0 "F - test-is-identifier-@") -15632 # . epilogue -15633 89/<- %esp 5/r32/ebp -15634 5d/pop-to-ebp -15635 c3/return -15636 -15637 test-is-identifier-backtick: -15638 # character before 'a' is invalid -15639 # . prologue -15640 55/push-ebp -15641 89/<- %ebp 4/r32/esp -15642 # (eax..ecx) = "`a" -15643 b8/copy-to-eax "`a"/imm32 -15644 8b/-> *eax 1/r32/ecx -15645 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15646 05/add-to-eax 4/imm32 -15647 # var slice/ecx: slice = {eax, ecx} -15648 51/push-ecx -15649 50/push-eax -15650 89/<- %ecx 4/r32/esp -15651 # -15652 (is-identifier? %ecx) -15653 (check-ints-equal %eax 0 "F - test-is-identifier-backtick") -15654 # . epilogue -15655 89/<- %esp 5/r32/ebp -15656 5d/pop-to-ebp -15657 c3/return -15658 -15659 test-is-identifier-curly-brace-open: -15660 # character after 'z' is invalid; also used for blocks -15661 # . prologue -15662 55/push-ebp -15663 89/<- %ebp 4/r32/esp -15664 # (eax..ecx) = "{a" -15665 b8/copy-to-eax "{a"/imm32 -15666 8b/-> *eax 1/r32/ecx -15667 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15668 05/add-to-eax 4/imm32 -15669 # var slice/ecx: slice = {eax, ecx} -15670 51/push-ecx -15671 50/push-eax -15672 89/<- %ecx 4/r32/esp -15673 # -15674 (is-identifier? %ecx) -15675 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-open") -15676 # . epilogue -15677 89/<- %esp 5/r32/ebp -15678 5d/pop-to-ebp -15679 c3/return -15680 -15681 test-is-identifier-curly-brace-close: -15682 # . prologue -15683 55/push-ebp -15684 89/<- %ebp 4/r32/esp -15685 # (eax..ecx) = "}a" -15686 b8/copy-to-eax "}a"/imm32 -15687 8b/-> *eax 1/r32/ecx -15688 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15689 05/add-to-eax 4/imm32 -15690 # var slice/ecx: slice = {eax, ecx} -15691 51/push-ecx -15692 50/push-eax -15693 89/<- %ecx 4/r32/esp -15694 # -15695 (is-identifier? %ecx) -15696 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-close") -15697 # . epilogue -15698 89/<- %esp 5/r32/ebp -15699 5d/pop-to-ebp -15700 c3/return -15701 -15702 test-is-identifier-hyphen: -15703 # disallow leading '-' since '->' has special meaning -15704 # . prologue -15705 55/push-ebp -15706 89/<- %ebp 4/r32/esp -15707 # (eax..ecx) = "-a" -15708 b8/copy-to-eax "-a"/imm32 -15709 8b/-> *eax 1/r32/ecx -15710 8d/copy-address *(eax+ecx+4) 1/r32/ecx -15711 05/add-to-eax 4/imm32 -15712 # var slice/ecx: slice = {eax, ecx} -15713 51/push-ecx -15714 50/push-eax -15715 89/<- %ecx 4/r32/esp -15716 # -15717 (is-identifier? %ecx) -15718 (check-ints-equal %eax 0 "F - test-is-identifier-hyphen") -15719 # . epilogue -15720 89/<- %esp 5/r32/ebp -15721 5d/pop-to-ebp -15722 c3/return -15723 -15724 populate-mu-function-body: # in: (addr buffered-file), out: (addr function), vars: (addr stack live-var), err: (addr buffered-file), ed: (addr exit-descriptor) -15725 # . prologue -15726 55/push-ebp -15727 89/<- %ebp 4/r32/esp -15728 # . save registers -15729 50/push-eax -15730 56/push-esi -15731 57/push-edi -15732 # esi = in -15733 8b/-> *(ebp+8) 6/r32/esi -15734 # edi = out -15735 8b/-> *(ebp+0xc) 7/r32/edi -15736 # initialize some global state -15737 c7 0/subop/copy *Curr-block-depth 1/imm32 -15738 # parse-mu-block(in, vars, out, out->body) -15739 8d/copy-address *(edi+0x18) 0/r32/eax # Function-body -15740 (parse-mu-block %esi *(ebp+0x10) %edi %eax *(ebp+0x14) *(ebp+0x18)) -15741 $populate-mu-function-body:end: -15742 # . restore registers -15743 5f/pop-to-edi -15744 5e/pop-to-esi -15745 58/pop-to-eax -15746 # . epilogue -15747 89/<- %esp 5/r32/ebp -15748 5d/pop-to-ebp -15749 c3/return -15750 -15751 # parses a block, assuming that the leading '{' has already been read by the caller -15752 parse-mu-block: # in: (addr buffered-file), vars: (addr stack live-var), fn: (addr function), out: (addr handle block), err: (addr buffered-file), ed: (addr exit-descriptor) -15753 # pseudocode: -15754 # var line: (stream byte 512) -15755 # var word-slice: slice -15756 # allocate(Heap, Stmt-size, out) -15757 # var out-addr: (addr block) = lookup(*out) -15758 # out-addr->tag = 0/block -15759 # out-addr->var = some unique name -15760 # push(vars, {out-addr->var, false}) -15761 # while true # line loop -15762 # clear-stream(line) -15763 # read-line-buffered(in, line) -15764 # if (line->write == 0) break # end of file -15765 # word-slice = next-mu-token(line) -15766 # if slice-empty?(word-slice) # end of line -15767 # continue -15768 # else if slice-starts-with?(word-slice, "#") -15769 # continue -15770 # else if slice-equal?(word-slice, "{") -15771 # assert(no-tokens-in(line)) -15772 # block = parse-mu-block(in, vars, fn) -15773 # append-to-block(out-addr, block) -15774 # else if slice-equal?(word-slice, "}") -15775 # break -15776 # else if slice-ends-with?(word-slice, ":") -15777 # # TODO: error-check the rest of 'line' -15778 # --word-slice->end to skip ':' -15779 # named-block = parse-mu-named-block(word-slice, in, vars, fn) -15780 # append-to-block(out-addr, named-block) -15781 # else if slice-equal?(word-slice, "var") -15782 # var-def = parse-mu-var-def(line, vars, fn) -15783 # append-to-block(out-addr, var-def) -15784 # else -15785 # stmt = parse-mu-stmt(line, vars, fn) -15786 # append-to-block(out-addr, stmt) -15787 # pop(vars) -15788 # -15789 # . prologue -15790 55/push-ebp -15791 89/<- %ebp 4/r32/esp -15792 # . save registers -15793 50/push-eax -15794 51/push-ecx -15795 52/push-edx -15796 53/push-ebx -15797 57/push-edi -15798 # var line/ecx: (stream byte 512) -15799 81 5/subop/subtract %esp 0x200/imm32 -15800 68/push 0x200/imm32/size -15801 68/push 0/imm32/read -15802 68/push 0/imm32/write -15803 89/<- %ecx 4/r32/esp -15804 # var word-slice/edx: slice -15805 68/push 0/imm32/end -15806 68/push 0/imm32/start -15807 89/<- %edx 4/r32/esp -15808 # allocate into out -15809 (allocate Heap *Stmt-size *(ebp+0x14)) -15810 # var out-addr/edi: (addr block) = lookup(*out) -15811 8b/-> *(ebp+0x14) 7/r32/edi -15812 (lookup *edi *(edi+4)) # => eax -15813 89/<- %edi 0/r32/eax -15814 # out-addr->tag is 0 (block) by default -15815 # set out-addr->var -15816 8d/copy-address *(edi+0xc) 0/r32/eax # Block-var -15817 (new-block-name *(ebp+0x10) %eax) -15818 # push(vars, out-addr->var) -15819 (push *(ebp+0xc) *(edi+0xc)) # Block-var -15820 (push *(ebp+0xc) *(edi+0x10)) # Block-var -15821 (push *(ebp+0xc) 0) # false -15822 # increment *Curr-block-depth -15823 ff 0/subop/increment *Curr-block-depth -15824 { -15825 $parse-mu-block:line-loop: -15826 # line = read-line-buffered(in) -15827 (clear-stream %ecx) -15828 (read-line-buffered *(ebp+8) %ecx) -15829 #? (write-buffered Stderr "line: ") -15830 #? (write-stream-data Stderr %ecx) -15831 #? #? (write-buffered Stderr Newline) # line has its own newline -15832 #? (flush Stderr) -15833 #? (rewind-stream %ecx) -15834 # if (line->write == 0) break -15835 81 7/subop/compare *ecx 0/imm32 -15836 0f 84/jump-if-= break/disp32 -15837 #? (write-buffered Stderr "vars:\n") -15838 #? (dump-vars *(ebp+0xc)) -15839 # word-slice = next-mu-token(line) -15840 (next-mu-token %ecx %edx) -15841 #? (write-buffered Stderr "word: ") -15842 #? (write-slice-buffered Stderr %edx) -15843 #? (write-buffered Stderr Newline) -15844 #? (flush Stderr) -15845 # if slice-empty?(word-slice) continue -15846 (slice-empty? %edx) -15847 3d/compare-eax-and 0/imm32/false -15848 0f 85/jump-if-!= loop/disp32 -15849 # if (slice-starts-with?(word-slice, '#') continue -15850 # . eax = *word-slice->start -15851 8b/-> *edx 0/r32/eax -15852 8a/copy-byte *eax 0/r32/AL -15853 81 4/subop/and %eax 0xff/imm32 -15854 # . if (eax == '#') continue -15855 3d/compare-eax-and 0x23/imm32/hash -15856 0f 84/jump-if-= loop/disp32 -15857 # if slice-equal?(word-slice, "{") -15858 { -15859 $parse-mu-block:check-for-block: -15860 (slice-equal? %edx "{") -15861 3d/compare-eax-and 0/imm32/false -15862 74/jump-if-= break/disp8 -15863 (check-no-tokens-left %ecx) -15864 # parse new block and append -15865 # . var tmp/eax: (handle block) -15866 68/push 0/imm32 -15867 68/push 0/imm32 -15868 89/<- %eax 4/r32/esp -15869 # . -15870 (parse-mu-block *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) -15871 (append-to-block Heap %edi *eax *(eax+4)) -15872 # . reclaim tmp -15873 81 0/subop/add %esp 8/imm32 -15874 # . -15875 e9/jump $parse-mu-block:line-loop/disp32 -15876 } -15877 # if slice-equal?(word-slice, "}") break -15878 $parse-mu-block:check-for-end: -15879 (slice-equal? %edx "}") -15880 3d/compare-eax-and 0/imm32/false -15881 0f 85/jump-if-!= break/disp32 -15882 # if slice-ends-with?(word-slice, ":") parse named block and append -15883 { -15884 $parse-mu-block:check-for-named-block: -15885 # . eax = *(word-slice->end-1) -15886 8b/-> *(edx+4) 0/r32/eax -15887 48/decrement-eax -15888 8a/copy-byte *eax 0/r32/AL -15889 81 4/subop/and %eax 0xff/imm32 -15890 # . if (eax != ':') break -15891 3d/compare-eax-and 0x3a/imm32/colon -15892 0f 85/jump-if-!= break/disp32 -15893 # TODO: error-check the rest of 'line' -15894 # -15895 # skip ':' -15896 ff 1/subop/decrement *(edx+4) # Slice-end -15897 # var tmp/eax: (handle block) -15898 68/push 0/imm32 -15899 68/push 0/imm32 -15900 89/<- %eax 4/r32/esp -15901 # -15902 (parse-mu-named-block %edx *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) -15903 (append-to-block Heap %edi *eax *(eax+4)) -15904 # reclaim tmp -15905 81 0/subop/add %esp 8/imm32 -15906 # -15907 e9/jump $parse-mu-block:line-loop/disp32 -15908 } -15909 # if slice-equal?(word-slice, "var") -15910 { -15911 $parse-mu-block:check-for-var: -15912 (slice-equal? %edx "var") -15913 3d/compare-eax-and 0/imm32/false -15914 74/jump-if-= break/disp8 -15915 # var tmp/eax: (handle block) -15916 68/push 0/imm32 -15917 68/push 0/imm32 -15918 89/<- %eax 4/r32/esp -15919 # -15920 (parse-mu-var-def %ecx *(ebp+0xc) %eax *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) -15921 (append-to-block Heap %edi *eax *(eax+4)) -15922 # reclaim tmp -15923 81 0/subop/add %esp 8/imm32 -15924 # -15925 e9/jump $parse-mu-block:line-loop/disp32 -15926 } -15927 $parse-mu-block:regular-stmt: -15928 # otherwise -15929 # var tmp/eax: (handle block) -15930 68/push 0/imm32 -15931 68/push 0/imm32 -15932 89/<- %eax 4/r32/esp -15933 # -15934 (parse-mu-stmt %ecx *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) -15935 (append-to-block Heap %edi *eax *(eax+4)) -15936 # reclaim tmp -15937 81 0/subop/add %esp 8/imm32 -15938 # -15939 e9/jump loop/disp32 -15940 } # end line loop -15941 (clean-up-blocks *(ebp+0xc) *Curr-block-depth *(ebp+0x10)) -15942 # decrement *Curr-block-depth -15943 ff 1/subop/decrement *Curr-block-depth -15944 # pop(vars) -15945 (pop *(ebp+0xc)) # => eax -15946 (pop *(ebp+0xc)) # => eax -15947 (pop *(ebp+0xc)) # => eax -15948 $parse-mu-block:end: -15949 # . reclaim locals -15950 81 0/subop/add %esp 0x214/imm32 -15951 # . restore registers -15952 5f/pop-to-edi -15953 5b/pop-to-ebx -15954 5a/pop-to-edx -15955 59/pop-to-ecx -15956 58/pop-to-eax -15957 # . epilogue -15958 89/<- %esp 5/r32/ebp -15959 5d/pop-to-ebp -15960 c3/return -15961 -15962 $parse-mu-block:abort: -15963 # error("'{' or '}' should be on its own line, but got '") -15964 (write-buffered *(ebp+0x18) "'{' or '}' should be on its own line, but got '") -15965 (rewind-stream %ecx) -15966 (write-stream-data *(ebp+0x18) %ecx) -15967 (write-buffered *(ebp+0x18) "'\n") -15968 (flush *(ebp+0x18)) -15969 (stop *(ebp+0x1c) 1) -15970 # never gets here -15971 -15972 new-block-name: # fn: (addr function), out: (addr handle var) -15973 # . prologue -15974 55/push-ebp -15975 89/<- %ebp 4/r32/esp -15976 # . save registers -15977 50/push-eax -15978 51/push-ecx -15979 52/push-edx -15980 # var n/ecx: int = len(fn->name) + 10 for an int + 2 for '$:' -15981 8b/-> *(ebp+8) 0/r32/eax -15982 (lookup *eax *(eax+4)) # Function-name Function-name => eax -15983 8b/-> *eax 0/r32/eax # String-size -15984 05/add-to-eax 0xd/imm32 # 10 + 2 for '$:' -15985 89/<- %ecx 0/r32/eax -15986 # var name/edx: (stream byte n) -15987 29/subtract-from %esp 1/r32/ecx -15988 ff 6/subop/push %ecx -15989 68/push 0/imm32/read -15990 68/push 0/imm32/write -15991 89/<- %edx 4/r32/esp -15992 (clear-stream %edx) -15993 # eax = fn->name -15994 8b/-> *(ebp+8) 0/r32/eax -15995 (lookup *eax *(eax+4)) # Function-name Function-name => eax -15996 # construct result using Next-block-index (and increment it) -15997 (write %edx "$") -15998 (write %edx %eax) -15999 (write %edx ":") -16000 (write-int32-hex %edx *Next-block-index) -16001 ff 0/subop/increment *Next-block-index -16002 # var s/eax: slice = {name->data, name->data + name->write} (clobbering edx) -16003 # . eax = name->write -16004 8b/-> *edx 0/r32/eax -16005 # . edx = name->data -16006 8d/copy-address *(edx+0xc) 2/r32/edx -16007 # . eax = name->write + name->data -16008 01/add-to %eax 2/r32/edx -16009 # . push {edx, eax} -16010 ff 6/subop/push %eax -16011 ff 6/subop/push %edx -16012 89/<- %eax 4/r32/esp -16013 # out = new literal(s) -16014 (new-literal Heap %eax *(ebp+0xc)) -16015 #? 8b/-> *(ebp+0xc) 0/r32/eax -16016 #? (write-buffered Stderr "type allocid in caller after new-literal: ") -16017 #? (write-int32-hex-buffered Stderr *(eax+8)) -16018 #? (write-buffered Stderr " for var ") -16019 #? (write-int32-hex-buffered Stderr %eax) -16020 #? (write-buffered Stderr Newline) -16021 #? (flush Stderr) -16022 $new-block-name:end: -16023 # . reclaim locals -16024 81 0/subop/add %ecx 0xc/imm32 # name.{read/write/len} -16025 81 0/subop/add %ecx 8/imm32 # slice -16026 01/add-to %esp 1/r32/ecx -16027 # . restore registers -16028 5a/pop-to-edx -16029 59/pop-to-ecx -16030 58/pop-to-eax -16031 # . epilogue -16032 89/<- %esp 5/r32/ebp -16033 5d/pop-to-ebp -16034 c3/return -16035 -16036 check-no-tokens-left: # line: (addr stream byte) -16037 # . prologue -16038 55/push-ebp -16039 89/<- %ebp 4/r32/esp -16040 # . save registers -16041 50/push-eax -16042 51/push-ecx -16043 # var s/ecx: slice -16044 68/push 0/imm32/end -16045 68/push 0/imm32/start -16046 89/<- %ecx 4/r32/esp -16047 # -16048 (next-mu-token *(ebp+8) %ecx) -16049 # if slice-empty?(s) return -16050 (slice-empty? %ecx) -16051 3d/compare-eax-and 0/imm32/false -16052 75/jump-if-!= $check-no-tokens-left:end/disp8 -16053 # if (slice-starts-with?(s, '#') return -16054 # . eax = *s->start -16055 8b/-> *edx 0/r32/eax -16056 8a/copy-byte *eax 0/r32/AL -16057 81 4/subop/and %eax 0xff/imm32 -16058 # . if (eax == '#') continue -16059 3d/compare-eax-and 0x23/imm32/hash -16060 74/jump-if-= $check-no-tokens-left:end/disp8 -16061 # abort -16062 (write-buffered Stderr "'{' or '}' should be on its own line, but got '") -16063 (rewind-stream %ecx) -16064 (write-stream 2 %ecx) -16065 (write-buffered Stderr "'\n") -16066 (flush Stderr) -16067 # . syscall(exit, 1) -16068 bb/copy-to-ebx 1/imm32 -16069 e8/call syscall_exit/disp32 -16070 # never gets here -16071 $check-no-tokens-left:end: -16072 # . reclaim locals -16073 81 0/subop/add %esp 8/imm32 -16074 # . restore registers -16075 59/pop-to-ecx -16076 58/pop-to-eax -16077 # . epilogue -16078 89/<- %esp 5/r32/ebp -16079 5d/pop-to-ebp -16080 c3/return -16081 -16082 parse-mu-named-block: # name: (addr slice), in: (addr buffered-file), vars: (addr stack live-var), fn: (addr function), out: (addr handle stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -16083 # pseudocode: -16084 # var v: (handle var) -16085 # new-literal(name, v) -16086 # push(vars, {v, false}) -16087 # parse-mu-block(in, vars, fn, out) -16088 # pop(vars) -16089 # out->tag = block -16090 # out->var = v -16091 # -16092 # . prologue -16093 55/push-ebp -16094 89/<- %ebp 4/r32/esp -16095 # . save registers -16096 50/push-eax -16097 51/push-ecx -16098 57/push-edi -16099 # var v/ecx: (handle var) -16100 68/push 0/imm32 -16101 68/push 0/imm32 -16102 89/<- %ecx 4/r32/esp -16103 # -16104 (new-literal Heap *(ebp+8) %ecx) -16105 # push(vars, v) -16106 (push *(ebp+0x10) *ecx) -16107 (push *(ebp+0x10) *(ecx+4)) -16108 (push *(ebp+0x10) 0) # false -16109 # -16110 (parse-mu-block *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c) *(ebp+0x20)) -16111 # pop v off vars -16112 (pop *(ebp+0x10)) # => eax -16113 (pop *(ebp+0x10)) # => eax -16114 (pop *(ebp+0x10)) # => eax -16115 # var out-addr/edi: (addr stmt) = lookup(*out) -16116 8b/-> *(ebp+0x18) 7/r32/edi -16117 (lookup *edi *(edi+4)) # => eax -16118 89/<- %edi 0/r32/eax -16119 # out-addr->tag = named-block -16120 c7 0/subop/copy *edi 0/imm32/block # Stmt-tag -16121 # out-addr->var = v -16122 8b/-> *ecx 0/r32/eax -16123 89/<- *(edi+0xc) 0/r32/eax # Block-var -16124 8b/-> *(ecx+4) 0/r32/eax -16125 89/<- *(edi+0x10) 0/r32/eax # Block-var -16126 $parse-mu-named-block:end: -16127 # . reclaim locals -16128 81 0/subop/add %esp 8/imm32 -16129 # . restore registers -16130 5f/pop-to-edi -16131 59/pop-to-ecx -16132 58/pop-to-eax -16133 # . epilogue -16134 89/<- %esp 5/r32/ebp -16135 5d/pop-to-ebp -16136 c3/return -16137 -16138 parse-mu-var-def: # line: (addr stream byte), vars: (addr stack live-var), out: (addr handle stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -16139 # . prologue -16140 55/push-ebp -16141 89/<- %ebp 4/r32/esp -16142 # . save registers -16143 50/push-eax -16144 51/push-ecx -16145 52/push-edx -16146 53/push-ebx -16147 57/push-edi -16148 # edi = out -16149 8b/-> *(ebp+0x10) 7/r32/edi -16150 # var word-slice/ecx: slice -16151 68/push 0/imm32/end -16152 68/push 0/imm32/start -16153 89/<- %ecx 4/r32/esp -16154 # var v/edx: (handle var) -16155 68/push 0/imm32 -16156 68/push 0/imm32 -16157 89/<- %edx 4/r32/esp -16158 # v = parse-var-with-type(next-mu-token(line)) -16159 (next-mu-token *(ebp+8) %ecx) -16160 (parse-var-with-type %ecx *(ebp+8) %edx *(ebp+0x18) *(ebp+0x1c)) -16161 # var v-addr/eax: (addr var) -16162 (lookup *edx *(edx+4)) # => eax -16163 # v->block-depth = *Curr-block-depth -16164 8b/-> *Curr-block-depth 3/r32/ebx -16165 89/<- *(eax+0x10) 3/r32/ebx # Var-block-depth -16166 # either v has no register and there's no more to this line -16167 8b/-> *(eax+0x18) 0/r32/eax # Var-register -16168 3d/compare-eax-and 0/imm32 -16169 { -16170 75/jump-if-!= break/disp8 -16171 # TODO: disallow vars of type 'byte' on the stack -16172 # ensure that there's nothing else on this line -16173 (next-mu-token *(ebp+8) %ecx) -16174 (slice-empty? %ecx) # => eax -16175 3d/compare-eax-and 0/imm32/false -16176 0f 84/jump-if-= $parse-mu-var-def:error2/disp32 -16177 # -16178 (new-var-def Heap *edx *(edx+4) %edi) -16179 e9/jump $parse-mu-var-def:update-vars/disp32 -16180 } -16181 # or v has a register and there's more to this line -16182 { -16183 0f 84/jump-if-= break/disp32 -16184 # TODO: disallow vars of type 'byte' in registers 'esi' or 'edi' -16185 # TODO: vars of type 'byte' should only be initialized by clearing to 0 -16186 # ensure that the next word is '<-' -16187 (next-mu-token *(ebp+8) %ecx) -16188 (slice-equal? %ecx "<-") # => eax -16189 3d/compare-eax-and 0/imm32/false -16190 0f 84/jump-if-= $parse-mu-var-def:error1/disp32 -16191 # -16192 (new-reg-var-def Heap *edx *(edx+4) %edi) -16193 (lookup *edi *(edi+4)) # => eax -16194 (add-operation-and-inputs-to-stmt %eax *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -16195 } -16196 $parse-mu-var-def:update-vars: -16197 # push 'v' at end of function -16198 (push *(ebp+0xc) *edx) -16199 (push *(ebp+0xc) *(edx+4)) -16200 (push *(ebp+0xc) 0) # Live-var-register-spilled is unused during parsing -16201 $parse-mu-var-def:end: -16202 # . reclaim locals -16203 81 0/subop/add %esp 0x10/imm32 -16204 # . restore registers -16205 5f/pop-to-edi -16206 5b/pop-to-ebx -16207 5a/pop-to-edx -16208 59/pop-to-ecx -16209 58/pop-to-eax -16210 # . epilogue -16211 89/<- %esp 5/r32/ebp -16212 5d/pop-to-ebp -16213 c3/return -16214 -16215 $parse-mu-var-def:error1: -16216 (rewind-stream *(ebp+8)) -16217 # error("register variable requires a valid instruction to initialize but got '" line "'\n") -16218 (write-buffered *(ebp+0x18) "register variable requires a valid instruction to initialize but got '") -16219 (flush *(ebp+0x18)) -16220 (write-stream-data *(ebp+0x18) *(ebp+8)) -16221 (write-buffered *(ebp+0x18) "'\n") -16222 (flush *(ebp+0x18)) -16223 (stop *(ebp+0x1c) 1) -16224 # never gets here -16225 -16226 $parse-mu-var-def:error2: -16227 (rewind-stream *(ebp+8)) -16228 # error("fn " fn ": var " var ": variables on the stack can't take an initializer\n") -16229 (write-buffered *(ebp+0x18) "fn ") -16230 8b/-> *(ebp+0x14) 0/r32/eax -16231 (lookup *eax *(eax+4)) # Function-name Function-name => eax -16232 (write-buffered *(ebp+0x18) %eax) -16233 (write-buffered *(ebp+0x18) ": var ") -16234 # var v-addr/eax: (addr var) = lookup(v) -16235 (lookup *edx *(edx+4)) # => eax -16236 (lookup *eax *(eax+4)) # Var-name Var-name => eax -16237 (write-buffered *(ebp+0x18) %eax) -16238 (write-buffered *(ebp+0x18) ": variables on the stack can't take an initializer\n") -16239 (flush *(ebp+0x18)) -16240 (stop *(ebp+0x1c) 1) -16241 # never gets here -16242 -16243 test-parse-mu-var-def: -16244 # 'var n: int' -16245 # . prologue -16246 55/push-ebp -16247 89/<- %ebp 4/r32/esp -16248 # setup -16249 8b/-> *Primitive-type-ids 0/r32/eax -16250 89/<- *Type-id 0/r32/eax # stream-write -16251 (clear-stream _test-input-stream) -16252 (write _test-input-stream "n: int\n") # caller has consumed the 'var' -16253 c7 0/subop/copy *Curr-block-depth 1/imm32 -16254 # var out/esi: (handle stmt) -16255 68/push 0/imm32 -16256 68/push 0/imm32 -16257 89/<- %esi 4/r32/esp -16258 # var vars/ecx: (stack (addr var) 16) -16259 81 5/subop/subtract %esp 0xc0/imm32 -16260 68/push 0xc0/imm32/size -16261 68/push 0/imm32/top -16262 89/<- %ecx 4/r32/esp -16263 (clear-stack %ecx) -16264 # convert -16265 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0) -16266 # var out-addr/esi: (addr stmt) -16267 (lookup *esi *(esi+4)) # => eax -16268 89/<- %esi 0/r32/eax -16269 # -16270 (check-ints-equal *esi 2 "F - test-parse-mu-var-def/tag") # Stmt-tag is var-def -16271 # var v/ecx: (addr var) = lookup(out->var) -16272 (lookup *(esi+4) *(esi+8)) # Vardef-var Vardef-var => eax -16273 89/<- %ecx 0/r32/eax -16274 # v->name -16275 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -16276 (check-strings-equal %eax "n" "F - test-parse-mu-var-def/var-name") -16277 # v->register -16278 (check-ints-equal *(ecx+0x18) 0 "F - test-parse-mu-var-def/var-register") # Var-register -16279 # v->block-depth -16280 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-var-def/output-block-depth") # Var-block-depth -16281 # v->type == int -16282 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -16283 (check-ints-equal *eax 1 "F - test-parse-mu-var-def/var-type:0") # Type-tree-is-atom -16284 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-var-def/var-type:1") # Type-tree-value -16285 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-var-def/var-type:2") # Type-tree-right -16286 # . epilogue -16287 89/<- %esp 5/r32/ebp -16288 5d/pop-to-ebp -16289 c3/return -16290 -16291 test-parse-mu-reg-var-def: -16292 # 'var n/eax: int <- copy 0' -16293 # . prologue -16294 55/push-ebp -16295 89/<- %ebp 4/r32/esp -16296 # setup -16297 8b/-> *Primitive-type-ids 0/r32/eax -16298 89/<- *Type-id 0/r32/eax # stream-write -16299 (clear-stream _test-input-stream) -16300 (write _test-input-stream "n/eax: int <- copy 0\n") # caller has consumed the 'var' -16301 c7 0/subop/copy *Curr-block-depth 1/imm32 -16302 # var out/esi: (handle stmt) -16303 68/push 0/imm32 -16304 68/push 0/imm32 -16305 89/<- %esi 4/r32/esp -16306 # var vars/ecx: (stack (addr var) 16) -16307 81 5/subop/subtract %esp 0xc0/imm32 -16308 68/push 0xc0/imm32/size -16309 68/push 0/imm32/top -16310 89/<- %ecx 4/r32/esp -16311 (clear-stack %ecx) -16312 # convert -16313 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0) -16314 # var out-addr/esi: (addr stmt) -16315 (lookup *esi *(esi+4)) # => eax -16316 89/<- %esi 0/r32/eax -16317 # -16318 (check-ints-equal *esi 3 "F - test-parse-mu-reg-var-def/tag") # Stmt-tag is reg-var-def -16319 # var v/ecx: (addr var) = lookup(out->outputs->value) -16320 # . eax: (addr stmt-var) = lookup(out->outputs) -16321 (lookup *(esi+0x14) *(esi+0x18)) # Regvardef-outputs Regvardef-outputs => eax -16322 # . -16323 (check-ints-equal *(eax+8) 0 "F - test-parse-mu-reg-var-def/single-output") # Stmt-var-next -16324 # . eax: (addr var) = lookup(eax->value) -16325 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -16326 # . ecx = eax -16327 89/<- %ecx 0/r32/eax -16328 # v->name -16329 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -16330 (check-strings-equal %eax "n" "F - test-parse-mu-reg-var-def/output-name") # Var-name -16331 # v->register -16332 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax -16333 (check-strings-equal %eax "eax" "F - test-parse-mu-reg-var-def/output-register") -16334 # v->block-depth -16335 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-reg-var-def/output-block-depth") # Var-block-depth -16336 # v->type == int -16337 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -16338 (check-ints-equal *eax 1 "F - test-parse-mu-reg-var-def/output-type:0") # Type-tree-is-atom -16339 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-reg-var-def/output-type:1") # Type-tree-value -16340 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-reg-var-def/output-type:2") # Type-tree-right -16341 # . epilogue -16342 89/<- %esp 5/r32/ebp -16343 5d/pop-to-ebp -16344 c3/return -16345 -16346 parse-mu-stmt: # line: (addr stream byte), vars: (addr stack live-var), fn: (addr function), out: (addr handle stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -16347 # pseudocode: -16348 # var name: slice -16349 # allocate(Heap, Stmt-size, out) -16350 # var out-addr: (addr stmt) = lookup(*out) -16351 # out-addr->tag = stmt -16352 # if stmt-has-outputs?(line) -16353 # while true -16354 # name = next-mu-token(line) -16355 # if (name == '<-') break -16356 # assert(is-identifier?(name)) -16357 # var v: (handle var) = lookup-var(name, vars) -16358 # out-addr->outputs = append(v, out-addr->outputs) -16359 # add-operation-and-inputs-to-stmt(out-addr, line, vars) +15584 51/push-ecx +15585 52/push-edx +15586 # clear out +15587 (zero-out *(ebp+0x10) *Handle-size) +15588 # var s/ecx: slice +15589 68/push 0/imm32 +15590 68/push 0/imm32 +15591 89/<- %ecx 4/r32/esp +15592 # s = next-mu-token(in) +15593 (next-mu-token *(ebp+0xc) %ecx) +15594 #? (write-buffered Stderr "tok: ") +15595 #? (write-slice-buffered Stderr %ecx) +15596 #? (write-buffered Stderr "$\n") +15597 #? (flush Stderr) +15598 # assert s != "" +15599 (slice-equal? %ecx "") # => eax +15600 3d/compare-eax-and 0/imm32/false +15601 0f 85/jump-if-!= $parse-type:abort/disp32 +15602 # assert s != "{" +15603 (slice-equal? %ecx "{") # => eax +15604 3d/compare-eax-and 0/imm32/false +15605 0f 85/jump-if-!= $parse-type:abort/disp32 +15606 # assert s != "}" +15607 (slice-equal? %ecx "}") # => eax +15608 3d/compare-eax-and 0/imm32/false +15609 0f 85/jump-if-!= $parse-type:abort/disp32 +15610 # assert s != "->" +15611 (slice-equal? %ecx "->") # => eax +15612 3d/compare-eax-and 0/imm32/false +15613 0f 85/jump-if-!= $parse-type:abort/disp32 +15614 # if (s == ")") return +15615 (slice-equal? %ecx ")") # => eax +15616 3d/compare-eax-and 0/imm32/false +15617 0f 85/jump-if-!= $parse-type:end/disp32 +15618 # out = new tree +15619 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10)) +15620 # var out-addr/edx: (addr type-tree) = lookup(*out) +15621 8b/-> *(ebp+0x10) 2/r32/edx +15622 (lookup *edx *(edx+4)) # => eax +15623 89/<- %edx 0/r32/eax +15624 { +15625 # if (s != "(") break +15626 (slice-equal? %ecx "(") # => eax +15627 3d/compare-eax-and 0/imm32/false +15628 0f 85/jump-if-!= break/disp32 +15629 # if s is a number, store it in the type's size field +15630 { +15631 $parse-type:check-for-int: +15632 # var tmp/eax: byte = *s->slice +15633 8b/-> *ecx 0/r32/eax +15634 8a/copy-byte *eax 0/r32/AL +15635 81 4/subop/and %eax 0xff/imm32 +15636 # TODO: raise an error on `var x: (array int a)` +15637 (is-decimal-digit? %eax) # => eax +15638 3d/compare-eax-and 0/imm32/false +15639 74/jump-if-= break/disp8 +15640 # +15641 (is-hex-int? %ecx) # => eax +15642 3d/compare-eax-and 0/imm32/false +15643 74/jump-if-= break/disp8 +15644 $parse-type:int: +15645 (check-mu-hex-int %ecx *(ebp+0x14) *(ebp+0x18)) +15646 (parse-hex-int-from-slice %ecx) # => eax +15647 c7 0/subop/copy *(edx+4) 9/imm32/type-id-array-capacity # Type-tree-value +15648 89/<- *(edx+8) 0/r32/eax # Type-tree-value-size +15649 e9/jump $parse-type:end/disp32 +15650 } +15651 $parse-type:atom: +15652 # out->is-atom? = true +15653 c7 0/subop/copy *edx 1/imm32/true # Type-tree-is-atom +15654 { +15655 $parse-type:check-for-type-parameter: +15656 # var tmp/eax: byte = *s->slice +15657 8b/-> *ecx 0/r32/eax +15658 8a/copy-byte *eax 0/r32/AL +15659 81 4/subop/and %eax 0xff/imm32 +15660 # if (tmp != '_') break +15661 3d/compare-eax-and 0x5f/imm32/_ +15662 75/jump-if-!= break/disp8 +15663 $parse-type:type-parameter: +15664 # out->value = type-parameter +15665 c7 0/subop/copy *(edx+4) 0xa/imm32/type-parameter # Type-tree-value +15666 # out->parameter-name = slice-to-string(ad, s) +15667 8d/copy-address *(edx+8) 0/r32/eax # Type-tree-parameter-name +15668 (slice-to-string *(ebp+8) %ecx %eax) +15669 e9/jump $parse-type:end/disp32 +15670 } +15671 $parse-type:non-type-parameter: +15672 # out->value = pos-or-insert-slice(Type-id, s) +15673 (pos-or-insert-slice Type-id %ecx) # => eax +15674 89/<- *(edx+4) 0/r32/eax # Type-tree-value +15675 e9/jump $parse-type:end/disp32 +15676 } +15677 $parse-type:non-atom: +15678 # otherwise s == "(" +15679 # out->left = parse-type(ad, in) +15680 8d/copy-address *(edx+4) 0/r32/eax # Type-tree-left +15681 (parse-type *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) +15682 # out->right = parse-type-tree(ad, in) +15683 8d/copy-address *(edx+0xc) 0/r32/eax # Type-tree-right +15684 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) +15685 $parse-type:end: +15686 # . reclaim locals +15687 81 0/subop/add %esp 8/imm32 +15688 # . restore registers +15689 5a/pop-to-edx +15690 59/pop-to-ecx +15691 58/pop-to-eax +15692 # . epilogue +15693 89/<- %esp 5/r32/ebp +15694 5d/pop-to-ebp +15695 c3/return +15696 +15697 $parse-type:abort: +15698 # error("unexpected token when parsing type: '" s "'\n") +15699 (write-buffered *(ebp+0x14) "unexpected token when parsing type: '") +15700 (write-slice-buffered *(ebp+0x14) %ecx) +15701 (write-buffered *(ebp+0x14) "'\n") +15702 (flush *(ebp+0x14)) +15703 (stop *(ebp+0x18) 1) +15704 # never gets here +15705 +15706 parse-type-tree: # ad: (addr allocation-descriptor), in: (addr stream byte), out: (addr handle type-tree), err: (addr buffered-file), ed: (addr exit-descriptor) +15707 # pseudocode: +15708 # var tmp: (handle type-tree) = parse-type(ad, in) +15709 # if tmp == 0 +15710 # return 0 +15711 # out = allocate(Type-tree) +15712 # out->left = tmp +15713 # out->right = parse-type-tree(ad, in) +15714 # +15715 # . prologue +15716 55/push-ebp +15717 89/<- %ebp 4/r32/esp +15718 # . save registers +15719 50/push-eax +15720 51/push-ecx +15721 52/push-edx +15722 # +15723 (zero-out *(ebp+0x10) *Handle-size) +15724 # var tmp/ecx: (handle type-tree) +15725 68/push 0/imm32 +15726 68/push 0/imm32 +15727 89/<- %ecx 4/r32/esp +15728 # tmp = parse-type(ad, in) +15729 (parse-type *(ebp+8) *(ebp+0xc) %ecx *(ebp+0x14) *(ebp+0x18)) +15730 # if (tmp == 0) return +15731 81 7/subop/compare *ecx 0/imm32 +15732 74/jump-if-= $parse-type-tree:end/disp8 +15733 # out = new tree +15734 (allocate *(ebp+8) *Type-tree-size *(ebp+0x10)) +15735 # var out-addr/edx: (addr tree) = lookup(*out) +15736 8b/-> *(ebp+0x10) 2/r32/edx +15737 (lookup *edx *(edx+4)) # => eax +15738 89/<- %edx 0/r32/eax +15739 # out->left = tmp +15740 8b/-> *ecx 0/r32/eax +15741 89/<- *(edx+4) 0/r32/eax # Type-tree-left +15742 8b/-> *(ecx+4) 0/r32/eax +15743 89/<- *(edx+8) 0/r32/eax # Type-tree-left +15744 # out->right = parse-type-tree(ad, in) +15745 8d/copy-address *(edx+0xc) 0/r32/eax # Type-tree-right +15746 (parse-type-tree *(ebp+8) *(ebp+0xc) %eax *(ebp+0x14) *(ebp+0x18)) +15747 $parse-type-tree:end: +15748 # . reclaim locals +15749 81 0/subop/add %esp 8/imm32 +15750 # . restore registers +15751 5a/pop-to-edx +15752 59/pop-to-ecx +15753 58/pop-to-eax +15754 # . epilogue +15755 89/<- %esp 5/r32/ebp +15756 5d/pop-to-ebp +15757 c3/return +15758 +15759 next-mu-token: # in: (addr stream byte), out: (addr slice) +15760 # pseudocode: +15761 # start: +15762 # skip-chars-matching-whitespace(in) +15763 # if in->read >= in->write # end of in +15764 # out = {0, 0} +15765 # return +15766 # out->start = &in->data[in->read] +15767 # var curr-byte/eax: byte = in->data[in->read] +15768 # if curr->byte == ',' # comment token +15769 # ++in->read +15770 # goto start +15771 # if curr-byte == '#' # comment +15772 # goto done # treat as eof +15773 # if curr-byte == '"' # string literal +15774 # skip-string(in) +15775 # goto done # no metadata +15776 # if curr-byte == '(' +15777 # ++in->read +15778 # goto done +15779 # if curr-byte == ')' +15780 # ++in->read +15781 # goto done +15782 # # read a word +15783 # while true +15784 # if in->read >= in->write +15785 # break +15786 # curr-byte = in->data[in->read] +15787 # if curr-byte == ' ' +15788 # break +15789 # if curr-byte == '\r' +15790 # break +15791 # if curr-byte == '\n' +15792 # break +15793 # if curr-byte == '(' +15794 # break +15795 # if curr-byte == ')' +15796 # break +15797 # if curr-byte == ',' +15798 # break +15799 # ++in->read +15800 # done: +15801 # out->end = &in->data[in->read] +15802 # +15803 # . prologue +15804 55/push-ebp +15805 89/<- %ebp 4/r32/esp +15806 # . save registers +15807 50/push-eax +15808 51/push-ecx +15809 56/push-esi +15810 57/push-edi +15811 # esi = in +15812 8b/-> *(ebp+8) 6/r32/esi +15813 # edi = out +15814 8b/-> *(ebp+0xc) 7/r32/edi +15815 $next-mu-token:start: +15816 (skip-chars-matching-whitespace %esi) +15817 $next-mu-token:check0: +15818 # if (in->read >= in->write) return out = {0, 0} +15819 # . ecx = in->read +15820 8b/-> *(esi+4) 1/r32/ecx +15821 # . if (ecx >= in->write) return out = {0, 0} +15822 3b/compare<- *esi 1/r32/ecx +15823 c7 0/subop/copy *edi 0/imm32 +15824 c7 0/subop/copy *(edi+4) 0/imm32 +15825 0f 8d/jump-if->= $next-mu-token:end/disp32 +15826 # out->start = &in->data[in->read] +15827 8d/copy-address *(esi+ecx+0xc) 0/r32/eax +15828 89/<- *edi 0/r32/eax +15829 # var curr-byte/eax: byte = in->data[in->read] +15830 31/xor-with %eax 0/r32/eax +15831 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL +15832 { +15833 $next-mu-token:check-for-comma: +15834 # if (curr-byte != ',') break +15835 3d/compare-eax-and 0x2c/imm32/comma +15836 75/jump-if-!= break/disp8 +15837 # ++in->read +15838 ff 0/subop/increment *(esi+4) +15839 # restart +15840 e9/jump $next-mu-token:start/disp32 +15841 } +15842 { +15843 $next-mu-token:check-for-comment: +15844 # if (curr-byte != '#') break +15845 3d/compare-eax-and 0x23/imm32/pound +15846 75/jump-if-!= break/disp8 +15847 # return eof +15848 e9/jump $next-mu-token:done/disp32 +15849 } +15850 { +15851 $next-mu-token:check-for-string-literal: +15852 # if (curr-byte != '"') break +15853 3d/compare-eax-and 0x22/imm32/dquote +15854 75/jump-if-!= break/disp8 +15855 (skip-string %esi) +15856 # return +15857 e9/jump $next-mu-token:done/disp32 +15858 } +15859 { +15860 $next-mu-token:check-for-open-paren: +15861 # if (curr-byte != '(') break +15862 3d/compare-eax-and 0x28/imm32/open-paren +15863 75/jump-if-!= break/disp8 +15864 # ++in->read +15865 ff 0/subop/increment *(esi+4) +15866 # return +15867 e9/jump $next-mu-token:done/disp32 +15868 } +15869 { +15870 $next-mu-token:check-for-close-paren: +15871 # if (curr-byte != ')') break +15872 3d/compare-eax-and 0x29/imm32/close-paren +15873 75/jump-if-!= break/disp8 +15874 # ++in->read +15875 ff 0/subop/increment *(esi+4) +15876 # return +15877 e9/jump $next-mu-token:done/disp32 +15878 } +15879 { +15880 $next-mu-token:regular-word-without-metadata: +15881 # if (in->read >= in->write) break +15882 # . ecx = in->read +15883 8b/-> *(esi+4) 1/r32/ecx +15884 # . if (ecx >= in->write) break +15885 3b/compare<- *esi 1/r32/ecx +15886 7d/jump-if->= break/disp8 +15887 # var c/eax: byte = in->data[in->read] +15888 31/xor-with %eax 0/r32/eax +15889 8a/copy-byte *(esi+ecx+0xc) 0/r32/AL +15890 # if (c == ' ') break +15891 3d/compare-eax-and 0x20/imm32/space +15892 74/jump-if-= break/disp8 +15893 # if (c == '\r') break +15894 3d/compare-eax-and 0xd/imm32/carriage-return +15895 74/jump-if-= break/disp8 +15896 # if (c == '\n') break +15897 3d/compare-eax-and 0xa/imm32/newline +15898 74/jump-if-= break/disp8 +15899 # if (c == '(') break +15900 3d/compare-eax-and 0x28/imm32/open-paren +15901 0f 84/jump-if-= break/disp32 +15902 # if (c == ')') break +15903 3d/compare-eax-and 0x29/imm32/close-paren +15904 0f 84/jump-if-= break/disp32 +15905 # if (c == ',') break +15906 3d/compare-eax-and 0x2c/imm32/comma +15907 0f 84/jump-if-= break/disp32 +15908 # ++in->read +15909 ff 0/subop/increment *(esi+4) +15910 # +15911 e9/jump loop/disp32 +15912 } +15913 $next-mu-token:done: +15914 # out->end = &in->data[in->read] +15915 8b/-> *(esi+4) 1/r32/ecx +15916 8d/copy-address *(esi+ecx+0xc) 0/r32/eax +15917 89/<- *(edi+4) 0/r32/eax +15918 $next-mu-token:end: +15919 # . restore registers +15920 5f/pop-to-edi +15921 5e/pop-to-esi +15922 59/pop-to-ecx +15923 58/pop-to-eax +15924 # . epilogue +15925 89/<- %esp 5/r32/ebp +15926 5d/pop-to-ebp +15927 c3/return +15928 +15929 pos-or-insert-slice: # arr: (addr stream (addr array byte)), s: (addr slice) -> index/eax: int +15930 # . prologue +15931 55/push-ebp +15932 89/<- %ebp 4/r32/esp +15933 # if (pos-slice(arr, s) != -1) return it +15934 (pos-slice *(ebp+8) *(ebp+0xc)) # => eax +15935 3d/compare-eax-and -1/imm32 +15936 75/jump-if-!= $pos-or-insert-slice:end/disp8 +15937 $pos-or-insert-slice:insert: +15938 # var s2/eax: (handle array byte) +15939 68/push 0/imm32 +15940 68/push 0/imm32 +15941 89/<- %eax 4/r32/esp +15942 (slice-to-string Heap *(ebp+0xc) %eax) +15943 # throw away alloc-id +15944 (lookup *eax *(eax+4)) # => eax +15945 (write-int *(ebp+8) %eax) +15946 (pos-slice *(ebp+8) *(ebp+0xc)) # => eax +15947 $pos-or-insert-slice:end: +15948 # . reclaim locals +15949 81 0/subop/add %esp 8/imm32 +15950 # . epilogue +15951 89/<- %esp 5/r32/ebp +15952 5d/pop-to-ebp +15953 c3/return +15954 +15955 # return the index in an array of strings matching 's', -1 if not found +15956 # index is denominated in elements, not bytes +15957 pos-slice: # arr: (addr stream (addr array byte)), s: (addr slice) -> index/eax: int +15958 # . prologue +15959 55/push-ebp +15960 89/<- %ebp 4/r32/esp +15961 # . save registers +15962 51/push-ecx +15963 52/push-edx +15964 53/push-ebx +15965 56/push-esi +15966 #? (write-buffered Stderr "pos-slice: ") +15967 #? (write-slice-buffered Stderr *(ebp+0xc)) +15968 #? (write-buffered Stderr "\n") +15969 #? (flush Stderr) +15970 # esi = arr +15971 8b/-> *(ebp+8) 6/r32/esi +15972 # var index/ecx: int = 0 +15973 b9/copy-to-ecx 0/imm32 +15974 # var curr/edx: (addr (addr array byte)) = arr->data +15975 8d/copy-address *(esi+0xc) 2/r32/edx +15976 # var max/ebx: (addr (addr array byte)) = &arr->data[arr->write] +15977 8b/-> *esi 3/r32/ebx +15978 8d/copy-address *(esi+ebx+0xc) 3/r32/ebx +15979 { +15980 #? (write-buffered Stderr " ") +15981 #? (write-int32-hex-buffered Stderr %ecx) +15982 #? (write-buffered Stderr "\n") +15983 #? (flush Stderr) +15984 # if (curr >= max) return -1 +15985 39/compare %edx 3/r32/ebx +15986 b8/copy-to-eax -1/imm32 +15987 73/jump-if-addr>= $pos-slice:end/disp8 +15988 # if (slice-equal?(s, *curr)) break +15989 (slice-equal? *(ebp+0xc) *edx) # => eax +15990 3d/compare-eax-and 0/imm32/false +15991 75/jump-if-!= break/disp8 +15992 # ++index +15993 41/increment-ecx +15994 # curr += 4 +15995 81 0/subop/add %edx 4/imm32 +15996 # +15997 eb/jump loop/disp8 +15998 } +15999 # return index +16000 89/<- %eax 1/r32/ecx +16001 $pos-slice:end: +16002 #? (write-buffered Stderr "=> ") +16003 #? (write-int32-hex-buffered Stderr %eax) +16004 #? (write-buffered Stderr "\n") +16005 # . restore registers +16006 5e/pop-to-esi +16007 5b/pop-to-ebx +16008 5a/pop-to-edx +16009 59/pop-to-ecx +16010 # . epilogue +16011 89/<- %esp 5/r32/ebp +16012 5d/pop-to-ebp +16013 c3/return +16014 +16015 test-parse-var-with-type: +16016 # . prologue +16017 55/push-ebp +16018 89/<- %ebp 4/r32/esp +16019 # setup +16020 8b/-> *Primitive-type-ids 0/r32/eax +16021 89/<- *Type-id 0/r32/eax # stream-write +16022 # (eax..ecx) = "x:" +16023 b8/copy-to-eax "x:"/imm32 +16024 8b/-> *eax 1/r32/ecx +16025 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16026 05/add-to-eax 4/imm32 +16027 # var slice/ecx: slice = {eax, ecx} +16028 51/push-ecx +16029 50/push-eax +16030 89/<- %ecx 4/r32/esp +16031 # _test-input-stream contains "int" +16032 (clear-stream _test-input-stream) +16033 (write _test-input-stream "int") +16034 # var v/edx: (handle var) +16035 68/push 0/imm32 +16036 68/push 0/imm32 +16037 89/<- %edx 4/r32/esp +16038 # +16039 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0) +16040 # var v-addr/edx: (addr var) = lookup(v) +16041 (lookup *edx *(edx+4)) # => eax +16042 89/<- %edx 0/r32/eax +16043 # check v-addr->name +16044 (lookup *edx *(edx+4)) # Var-name Var-name => eax +16045 (check-strings-equal %eax "x" "F - test-parse-var-with-type/name") +16046 # check v-addr->type +16047 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +16048 (check-ints-equal *eax 1 "F - test-parse-var-with-type/type:0") # Type-tree-is-atom +16049 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type/type:1") # Type-tree-value +16050 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type/type:2") # Type-tree-right +16051 # . epilogue +16052 89/<- %esp 5/r32/ebp +16053 5d/pop-to-ebp +16054 c3/return +16055 +16056 test-parse-var-with-type-and-register: +16057 # . prologue +16058 55/push-ebp +16059 89/<- %ebp 4/r32/esp +16060 # setup +16061 8b/-> *Primitive-type-ids 0/r32/eax +16062 89/<- *Type-id 0/r32/eax # stream-write +16063 # (eax..ecx) = "x/eax:" +16064 b8/copy-to-eax "x/eax:"/imm32 +16065 8b/-> *eax 1/r32/ecx +16066 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16067 05/add-to-eax 4/imm32 +16068 # var slice/ecx: slice = {eax, ecx} +16069 51/push-ecx +16070 50/push-eax +16071 89/<- %ecx 4/r32/esp +16072 # _test-input-stream contains "int" +16073 (clear-stream _test-input-stream) +16074 (write _test-input-stream "int") +16075 # var v/edx: (handle var) +16076 68/push 0/imm32 +16077 68/push 0/imm32 +16078 89/<- %edx 4/r32/esp +16079 # +16080 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0) +16081 # var v-addr/edx: (addr var) = lookup(v) +16082 (lookup *edx *(edx+4)) # => eax +16083 89/<- %edx 0/r32/eax +16084 # check v-addr->name +16085 (lookup *edx *(edx+4)) # Var-name Var-name => eax +16086 (check-strings-equal %eax "x" "F - test-parse-var-with-type-and-register/name") +16087 # check v-addr->register +16088 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +16089 (check-strings-equal %eax "eax" "F - test-parse-var-with-type-and-register/register") +16090 # check v-addr->type +16091 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +16092 (check-ints-equal *eax 1 "F - test-parse-var-with-type-and-register/type:0") # Type-tree-is-atom +16093 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-type-and-register/type:1") # Type-tree-left +16094 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-type-and-register/type:2") # Type-tree-right +16095 # . epilogue +16096 89/<- %esp 5/r32/ebp +16097 5d/pop-to-ebp +16098 c3/return +16099 +16100 test-parse-var-with-trailing-characters: +16101 # . prologue +16102 55/push-ebp +16103 89/<- %ebp 4/r32/esp +16104 # setup +16105 8b/-> *Primitive-type-ids 0/r32/eax +16106 89/<- *Type-id 0/r32/eax # stream-write +16107 # (eax..ecx) = "x:" +16108 b8/copy-to-eax "x:"/imm32 +16109 8b/-> *eax 1/r32/ecx +16110 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16111 05/add-to-eax 4/imm32 +16112 # var slice/ecx: slice = {eax, ecx} +16113 51/push-ecx +16114 50/push-eax +16115 89/<- %ecx 4/r32/esp +16116 # _test-input-stream contains "int," +16117 (clear-stream _test-input-stream) +16118 (write _test-input-stream "int,") +16119 # var v/edx: (handle var) +16120 68/push 0/imm32 +16121 68/push 0/imm32 +16122 89/<- %edx 4/r32/esp +16123 # +16124 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0) +16125 # var v-addr/edx: (addr var) = lookup(v) +16126 (lookup *edx *(edx+4)) # => eax +16127 89/<- %edx 0/r32/eax +16128 # check v-addr->name +16129 (lookup *edx *(edx+4)) # Var-name Var-name => eax +16130 (check-strings-equal %eax "x" "F - test-parse-var-with-trailing-characters/name") +16131 # check v-addr->register +16132 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-trailing-characters/register") # Var-register +16133 # check v-addr->type +16134 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +16135 (check-ints-equal *eax 1 "F - test-parse-var-with-trailing-characters/type:0") # Type-tree-is-atom +16136 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-trailing-characters/type:1") # Type-tree-left +16137 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-trailing-characters/type:1") # Type-tree-right +16138 # . epilogue +16139 89/<- %esp 5/r32/ebp +16140 5d/pop-to-ebp +16141 c3/return +16142 +16143 test-parse-var-with-register-and-trailing-characters: +16144 # . prologue +16145 55/push-ebp +16146 89/<- %ebp 4/r32/esp +16147 # setup +16148 8b/-> *Primitive-type-ids 0/r32/eax +16149 89/<- *Type-id 0/r32/eax # stream-write +16150 # (eax..ecx) = "x/eax:" +16151 b8/copy-to-eax "x/eax:"/imm32 +16152 8b/-> *eax 1/r32/ecx +16153 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16154 05/add-to-eax 4/imm32 +16155 # var slice/ecx: slice = {eax, ecx} +16156 51/push-ecx +16157 50/push-eax +16158 89/<- %ecx 4/r32/esp +16159 # _test-input-stream contains "int," +16160 (clear-stream _test-input-stream) +16161 (write _test-input-stream "int,") +16162 # var v/edx: (handle var) +16163 68/push 0/imm32 +16164 68/push 0/imm32 +16165 89/<- %edx 4/r32/esp +16166 # +16167 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0) +16168 # var v-addr/edx: (addr var) = lookup(v) +16169 (lookup *edx *(edx+4)) # => eax +16170 89/<- %edx 0/r32/eax +16171 # check v-addr->name +16172 (lookup *edx *(edx+4)) # Var-name Var-name => eax +16173 (check-strings-equal %eax "x" "F - test-parse-var-with-register-and-trailing-characters/name") +16174 # check v-addr->register +16175 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +16176 (check-strings-equal %eax "eax" "F - test-parse-var-with-register-and-trailing-characters/register") +16177 # check v-addr->type +16178 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +16179 (check-ints-equal *eax 1 "F - test-parse-var-with-register-and-trailing-characters/type:0") # Type-tree-is-atom +16180 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-register-and-trailing-characters/type:1") # Type-tree-left +16181 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-register-and-trailing-characters/type:2") # Type-tree-right +16182 # . epilogue +16183 89/<- %esp 5/r32/ebp +16184 5d/pop-to-ebp +16185 c3/return +16186 +16187 test-parse-var-with-compound-type: +16188 # . prologue +16189 55/push-ebp +16190 89/<- %ebp 4/r32/esp +16191 # setup +16192 8b/-> *Primitive-type-ids 0/r32/eax +16193 89/<- *Type-id 0/r32/eax # stream-write +16194 # (eax..ecx) = "x:" +16195 b8/copy-to-eax "x:"/imm32 +16196 8b/-> *eax 1/r32/ecx +16197 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16198 05/add-to-eax 4/imm32 +16199 # var slice/ecx: slice = {eax, ecx} +16200 51/push-ecx +16201 50/push-eax +16202 89/<- %ecx 4/r32/esp +16203 # _test-input-stream contains "(addr int)" +16204 (clear-stream _test-input-stream) +16205 (write _test-input-stream "(addr int)") +16206 # var v/edx: (handle var) +16207 68/push 0/imm32 +16208 68/push 0/imm32 +16209 89/<- %edx 4/r32/esp +16210 # +16211 (parse-var-with-type %ecx _test-input-stream %edx 0 Stderr 0) +16212 # var v-addr/edx: (addr var) = lookup(v) +16213 (lookup *edx *(edx+4)) # => eax +16214 89/<- %edx 0/r32/eax +16215 # check v-addr->name +16216 (lookup *edx *(edx+4)) # Var-name Var-name => eax +16217 (check-strings-equal %eax "x" "F - test-parse-var-with-compound-type/name") +16218 # check v-addr->register +16219 (check-ints-equal *(edx+0x18) 0 "F - test-parse-var-with-compound-type/register") # Var-register +16220 # - check v-addr->type +16221 # var type/edx: (addr type-tree) = var->type +16222 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +16223 89/<- %edx 0/r32/eax +16224 # type is a non-atom +16225 (check-ints-equal *edx 0 "F - test-parse-var-with-compound-type/type:0") # Type-tree-is-atom +16226 # type->left == atom(addr) +16227 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +16228 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:1") # Type-tree-is-atom +16229 (check-ints-equal *(eax+4) 2 "F - test-parse-var-with-compound-type/type:2") # Type-tree-value +16230 # type->right->left == atom(int) +16231 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax +16232 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +16233 (check-ints-equal *eax 1 "F - test-parse-var-with-compound-type/type:3") # Type-tree-is-atom +16234 (check-ints-equal *(eax+4) 1 "F - test-parse-var-with-compound-type/type:4") # Type-tree-value +16235 # type->right->right == null +16236 (check-ints-equal *(eax+0xc) 0 "F - test-parse-var-with-compound-type/type:5") # Type-tree-right +16237 # . epilogue +16238 89/<- %esp 5/r32/ebp +16239 5d/pop-to-ebp +16240 c3/return +16241 +16242 # identifier starts with a letter or '$' or '_' +16243 # no constraints at the moment on later letters +16244 # all we really want to do so far is exclude '{', '}' and '->' +16245 is-identifier?: # in: (addr slice) -> result/eax: boolean +16246 # . prologue +16247 55/push-ebp +16248 89/<- %ebp 4/r32/esp +16249 # if (slice-empty?(in)) return false +16250 (slice-empty? *(ebp+8)) # => eax +16251 3d/compare-eax-and 0/imm32/false +16252 75/jump-if-!= $is-identifier?:false/disp8 +16253 # var c/eax: byte = *in->start +16254 8b/-> *(ebp+8) 0/r32/eax +16255 8b/-> *eax 0/r32/eax +16256 8a/copy-byte *eax 0/r32/AL +16257 81 4/subop/and %eax 0xff/imm32 +16258 # if (c == '$') return true +16259 3d/compare-eax-and 0x24/imm32/$ +16260 74/jump-if-= $is-identifier?:true/disp8 +16261 # if (c == '_') return true +16262 3d/compare-eax-and 0x5f/imm32/_ +16263 74/jump-if-= $is-identifier?:true/disp8 +16264 # drop case +16265 25/and-eax-with 0x5f/imm32 +16266 # if (c < 'A') return false +16267 3d/compare-eax-and 0x41/imm32/A +16268 7c/jump-if-< $is-identifier?:false/disp8 +16269 # if (c > 'Z') return false +16270 3d/compare-eax-and 0x5a/imm32/Z +16271 7f/jump-if-> $is-identifier?:false/disp8 +16272 # otherwise return true +16273 $is-identifier?:true: +16274 b8/copy-to-eax 1/imm32/true +16275 eb/jump $is-identifier?:end/disp8 +16276 $is-identifier?:false: +16277 b8/copy-to-eax 0/imm32/false +16278 $is-identifier?:end: +16279 # . epilogue +16280 89/<- %esp 5/r32/ebp +16281 5d/pop-to-ebp +16282 c3/return +16283 +16284 test-is-identifier-dollar: +16285 # . prologue +16286 55/push-ebp +16287 89/<- %ebp 4/r32/esp +16288 # (eax..ecx) = "$a" +16289 b8/copy-to-eax "$a"/imm32 +16290 8b/-> *eax 1/r32/ecx +16291 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16292 05/add-to-eax 4/imm32 +16293 # var slice/ecx: slice = {eax, ecx} +16294 51/push-ecx +16295 50/push-eax +16296 89/<- %ecx 4/r32/esp +16297 # +16298 (is-identifier? %ecx) +16299 (check-ints-equal %eax 1 "F - test-is-identifier-dollar") +16300 # . epilogue +16301 89/<- %esp 5/r32/ebp +16302 5d/pop-to-ebp +16303 c3/return +16304 +16305 test-is-identifier-underscore: +16306 # . prologue +16307 55/push-ebp +16308 89/<- %ebp 4/r32/esp +16309 # (eax..ecx) = "_a" +16310 b8/copy-to-eax "_a"/imm32 +16311 8b/-> *eax 1/r32/ecx +16312 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16313 05/add-to-eax 4/imm32 +16314 # var slice/ecx: slice = {eax, ecx} +16315 51/push-ecx +16316 50/push-eax +16317 89/<- %ecx 4/r32/esp +16318 # +16319 (is-identifier? %ecx) +16320 (check-ints-equal %eax 1 "F - test-is-identifier-underscore") +16321 # . epilogue +16322 89/<- %esp 5/r32/ebp +16323 5d/pop-to-ebp +16324 c3/return +16325 +16326 test-is-identifier-a: +16327 # . prologue +16328 55/push-ebp +16329 89/<- %ebp 4/r32/esp +16330 # (eax..ecx) = "a$" +16331 b8/copy-to-eax "a$"/imm32 +16332 8b/-> *eax 1/r32/ecx +16333 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16334 05/add-to-eax 4/imm32 +16335 # var slice/ecx: slice = {eax, ecx} +16336 51/push-ecx +16337 50/push-eax +16338 89/<- %ecx 4/r32/esp +16339 # +16340 (is-identifier? %ecx) +16341 (check-ints-equal %eax 1 "F - test-is-identifier-a") +16342 # . epilogue +16343 89/<- %esp 5/r32/ebp +16344 5d/pop-to-ebp +16345 c3/return +16346 +16347 test-is-identifier-z: +16348 # . prologue +16349 55/push-ebp +16350 89/<- %ebp 4/r32/esp +16351 # (eax..ecx) = "z$" +16352 b8/copy-to-eax "z$"/imm32 +16353 8b/-> *eax 1/r32/ecx +16354 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16355 05/add-to-eax 4/imm32 +16356 # var slice/ecx: slice = {eax, ecx} +16357 51/push-ecx +16358 50/push-eax +16359 89/<- %ecx 4/r32/esp 16360 # -16361 # . prologue -16362 55/push-ebp -16363 89/<- %ebp 4/r32/esp -16364 # . save registers -16365 50/push-eax -16366 51/push-ecx -16367 52/push-edx -16368 53/push-ebx -16369 57/push-edi -16370 # var name/ecx: slice -16371 68/push 0/imm32/end -16372 68/push 0/imm32/start -16373 89/<- %ecx 4/r32/esp -16374 # var is-deref?/edx: boolean = false -16375 ba/copy-to-edx 0/imm32/false -16376 # var v: (handle var) -16377 68/push 0/imm32 -16378 68/push 0/imm32 -16379 89/<- %ebx 4/r32/esp -16380 # -16381 (allocate Heap *Stmt-size *(ebp+0x14)) -16382 # var out-addr/edi: (addr stmt) = lookup(*out) -16383 8b/-> *(ebp+0x14) 7/r32/edi -16384 (lookup *edi *(edi+4)) # => eax -16385 89/<- %edi 0/r32/eax -16386 # out-addr->tag = 1/stmt -16387 c7 0/subop/copy *edi 1/imm32/stmt1 # Stmt-tag -16388 { -16389 (stmt-has-outputs? *(ebp+8)) -16390 3d/compare-eax-and 0/imm32/false -16391 0f 84/jump-if-= break/disp32 -16392 { -16393 $parse-mu-stmt:read-outputs: -16394 # name = next-mu-token(line) -16395 (next-mu-token *(ebp+8) %ecx) -16396 # if slice-empty?(word-slice) break -16397 (slice-empty? %ecx) # => eax -16398 3d/compare-eax-and 0/imm32/false -16399 0f 85/jump-if-!= break/disp32 -16400 # if (name == "<-") break -16401 (slice-equal? %ecx "<-") # => eax -16402 3d/compare-eax-and 0/imm32/false -16403 0f 85/jump-if-!= break/disp32 -16404 # is-deref? = false -16405 ba/copy-to-edx 0/imm32/false -16406 # if (slice-starts-with?(name, '*')) ++name->start and set is-deref? -16407 8b/-> *ecx 0/r32/eax # Slice-start -16408 8a/copy-byte *eax 0/r32/AL -16409 81 4/subop/and %eax 0xff/imm32 -16410 3d/compare-eax-and 0x2a/imm32/asterisk -16411 { -16412 75/jump-if-!= break/disp8 -16413 ff 0/subop/increment *ecx -16414 ba/copy-to-edx 1/imm32/true -16415 } -16416 # assert(is-identifier?(name)) -16417 (is-identifier? %ecx) # => eax -16418 3d/compare-eax-and 0/imm32/false -16419 0f 84/jump-if-= $parse-mu-stmt:abort/disp32 -16420 # -16421 (lookup-var %ecx *(ebp+0xc) %ebx *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) -16422 8d/copy-address *(edi+0x14) 0/r32/eax # Stmt1-outputs -16423 (append-stmt-var Heap *ebx *(ebx+4) *(edi+0x14) *(edi+0x18) %edx %eax) # Stmt1-outputs -16424 # -16425 e9/jump loop/disp32 -16426 } -16427 } -16428 (add-operation-and-inputs-to-stmt %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) -16429 $parse-mu-stmt:end: -16430 # . reclaim locals -16431 81 0/subop/add %esp 0x10/imm32 -16432 # . restore registers -16433 5f/pop-to-edi -16434 5b/pop-to-ebx -16435 5a/pop-to-edx -16436 59/pop-to-ecx -16437 58/pop-to-eax -16438 # . epilogue -16439 89/<- %esp 5/r32/ebp -16440 5d/pop-to-ebp -16441 c3/return -16442 -16443 $parse-mu-stmt:abort: -16444 # error("invalid identifier '" name "'\n") -16445 (write-buffered *(ebp+0x18) "invalid identifier '") -16446 (write-slice-buffered *(ebp+0x18) %ecx) -16447 (write-buffered *(ebp+0x18) "'\n") -16448 (flush *(ebp+0x18)) -16449 (stop *(ebp+0x1c) 1) -16450 # never gets here -16451 -16452 add-operation-and-inputs-to-stmt: # stmt: (addr stmt), line: (addr stream byte), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -16453 # pseudocode: -16454 # stmt->name = slice-to-string(next-mu-token(line)) -16455 # while true -16456 # name = next-mu-token(line) -16457 # v = lookup-var-or-literal(name) -16458 # stmt->inouts = append(v, stmt->inouts) -16459 # -16460 # . prologue -16461 55/push-ebp -16462 89/<- %ebp 4/r32/esp -16463 # . save registers -16464 50/push-eax +16361 (is-identifier? %ecx) +16362 (check-ints-equal %eax 1 "F - test-is-identifier-z") +16363 # . epilogue +16364 89/<- %esp 5/r32/ebp +16365 5d/pop-to-ebp +16366 c3/return +16367 +16368 test-is-identifier-A: +16369 # . prologue +16370 55/push-ebp +16371 89/<- %ebp 4/r32/esp +16372 # (eax..ecx) = "A$" +16373 b8/copy-to-eax "A$"/imm32 +16374 8b/-> *eax 1/r32/ecx +16375 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16376 05/add-to-eax 4/imm32 +16377 # var slice/ecx: slice = {eax, ecx} +16378 51/push-ecx +16379 50/push-eax +16380 89/<- %ecx 4/r32/esp +16381 # +16382 (is-identifier? %ecx) +16383 (check-ints-equal %eax 1 "F - test-is-identifier-A") +16384 # . epilogue +16385 89/<- %esp 5/r32/ebp +16386 5d/pop-to-ebp +16387 c3/return +16388 +16389 test-is-identifier-Z: +16390 # . prologue +16391 55/push-ebp +16392 89/<- %ebp 4/r32/esp +16393 # (eax..ecx) = "Z$" +16394 b8/copy-to-eax "Z$"/imm32 +16395 8b/-> *eax 1/r32/ecx +16396 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16397 05/add-to-eax 4/imm32 +16398 # var slice/ecx: slice = {eax, ecx} +16399 51/push-ecx +16400 50/push-eax +16401 89/<- %ecx 4/r32/esp +16402 # +16403 (is-identifier? %ecx) +16404 (check-ints-equal %eax 1 "F - test-is-identifier-Z") +16405 # . epilogue +16406 89/<- %esp 5/r32/ebp +16407 5d/pop-to-ebp +16408 c3/return +16409 +16410 test-is-identifier-at: +16411 # character before 'A' is invalid +16412 # . prologue +16413 55/push-ebp +16414 89/<- %ebp 4/r32/esp +16415 # (eax..ecx) = "@a" +16416 b8/copy-to-eax "@a"/imm32 +16417 8b/-> *eax 1/r32/ecx +16418 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16419 05/add-to-eax 4/imm32 +16420 # var slice/ecx: slice = {eax, ecx} +16421 51/push-ecx +16422 50/push-eax +16423 89/<- %ecx 4/r32/esp +16424 # +16425 (is-identifier? %ecx) +16426 (check-ints-equal %eax 0 "F - test-is-identifier-@") +16427 # . epilogue +16428 89/<- %esp 5/r32/ebp +16429 5d/pop-to-ebp +16430 c3/return +16431 +16432 test-is-identifier-square-bracket: +16433 # character after 'Z' is invalid +16434 # . prologue +16435 55/push-ebp +16436 89/<- %ebp 4/r32/esp +16437 # (eax..ecx) = "[a" +16438 b8/copy-to-eax "[a"/imm32 +16439 8b/-> *eax 1/r32/ecx +16440 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16441 05/add-to-eax 4/imm32 +16442 # var slice/ecx: slice = {eax, ecx} +16443 51/push-ecx +16444 50/push-eax +16445 89/<- %ecx 4/r32/esp +16446 # +16447 (is-identifier? %ecx) +16448 (check-ints-equal %eax 0 "F - test-is-identifier-@") +16449 # . epilogue +16450 89/<- %esp 5/r32/ebp +16451 5d/pop-to-ebp +16452 c3/return +16453 +16454 test-is-identifier-backtick: +16455 # character before 'a' is invalid +16456 # . prologue +16457 55/push-ebp +16458 89/<- %ebp 4/r32/esp +16459 # (eax..ecx) = "`a" +16460 b8/copy-to-eax "`a"/imm32 +16461 8b/-> *eax 1/r32/ecx +16462 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16463 05/add-to-eax 4/imm32 +16464 # var slice/ecx: slice = {eax, ecx} 16465 51/push-ecx -16466 52/push-edx -16467 53/push-ebx -16468 56/push-esi -16469 57/push-edi -16470 # edi = stmt -16471 8b/-> *(ebp+8) 7/r32/edi -16472 # var name/ecx: slice -16473 68/push 0/imm32/end -16474 68/push 0/imm32/start -16475 89/<- %ecx 4/r32/esp -16476 # var is-deref?/edx: boolean = false -16477 ba/copy-to-edx 0/imm32/false -16478 # var v/esi: (handle var) -16479 68/push 0/imm32 -16480 68/push 0/imm32 -16481 89/<- %esi 4/r32/esp -16482 $add-operation-and-inputs-to-stmt:read-operation: -16483 (next-mu-token *(ebp+0xc) %ecx) -16484 8d/copy-address *(edi+4) 0/r32/eax # Stmt1-operation or Regvardef-operationStmt1-operation or Regvardef-operation -16485 (slice-to-string Heap %ecx %eax) -16486 # var is-get?/ebx: boolean = (name == "get") -16487 (slice-equal? %ecx "get") # => eax -16488 89/<- %ebx 0/r32/eax -16489 { -16490 $add-operation-and-inputs-to-stmt:read-inouts: -16491 # name = next-mu-token(line) -16492 (next-mu-token *(ebp+0xc) %ecx) -16493 # if slice-empty?(word-slice) break -16494 (slice-empty? %ecx) # => eax -16495 3d/compare-eax-and 0/imm32/false -16496 0f 85/jump-if-!= break/disp32 -16497 # if (name == "<-") abort -16498 (slice-equal? %ecx "<-") -16499 3d/compare-eax-and 0/imm32/false -16500 0f 85/jump-if-!= $add-operation-and-inputs-to-stmt:abort/disp32 -16501 # if (is-get? && second operand) lookup or create offset -16502 { -16503 81 7/subop/compare %ebx 0/imm32/false -16504 74/jump-if-= break/disp8 -16505 (lookup *(edi+0xc) *(edi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -16506 3d/compare-eax-and 0/imm32 -16507 74/jump-if-= break/disp8 -16508 (lookup-or-create-constant %eax %ecx %esi) -16509 #? (lookup *esi *(esi+4)) -16510 #? (write-buffered Stderr "creating new output var ") -16511 #? (write-int32-hex-buffered Stderr %eax) -16512 #? (write-buffered Stderr " for field called ") -16513 #? (write-slice-buffered Stderr %ecx) -16514 #? (write-buffered Stderr "; var name ") -16515 #? (lookup *eax *(eax+4)) # Var-name -16516 #? (write-buffered Stderr %eax) -16517 #? (write-buffered Stderr Newline) -16518 #? (flush Stderr) -16519 e9/jump $add-operation-and-inputs-to-stmt:save-var/disp32 -16520 } -16521 # is-deref? = false -16522 ba/copy-to-edx 0/imm32/false -16523 # if (slice-starts-with?(name, '*')) ++name->start and set is-deref? -16524 8b/-> *ecx 0/r32/eax # Slice-start -16525 8a/copy-byte *eax 0/r32/AL -16526 81 4/subop/and %eax 0xff/imm32 -16527 3d/compare-eax-and 0x2a/imm32/asterisk -16528 { -16529 75/jump-if-!= break/disp8 -16530 $add-operation-and-inputs-to-stmt:inout-is-deref: -16531 ff 0/subop/increment *ecx -16532 ba/copy-to-edx 1/imm32/true -16533 } -16534 (lookup-var-or-literal %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -16535 # if (is-deref?) some additional checks -16536 81 7/subop/compare %edx 0/imm32/false -16537 { -16538 74/jump-if-= break/disp8 -16539 # if var is not in register, abort -16540 (lookup *esi *(esi+4)) # => eax -16541 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register -16542 0f 84/jump-if-= $add-operation-and-inputs-to-stmt:error-deref-on-stack/disp32 -16543 # if var is not an address, abort -16544 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -16545 (is-mu-addr-type? %eax) # => eax -16546 3d/compare-eax-and 0/imm32/false -16547 0f 84/jump-if-= $add-operation-and-inputs-to-stmt:error-deref-non-addr/disp32 -16548 } -16549 $add-operation-and-inputs-to-stmt:save-var: -16550 8d/copy-address *(edi+0xc) 0/r32/eax -16551 (append-stmt-var Heap *esi *(esi+4) *(edi+0xc) *(edi+0x10) %edx %eax) # Stmt1-inouts or Regvardef-inouts -16552 # -16553 e9/jump loop/disp32 -16554 } -16555 $add-operation-and-inputs-to-stmt:end: -16556 # . reclaim locals -16557 81 0/subop/add %esp 0x10/imm32 -16558 # . restore registers -16559 5f/pop-to-edi -16560 5e/pop-to-esi -16561 5b/pop-to-ebx -16562 5a/pop-to-edx -16563 59/pop-to-ecx -16564 58/pop-to-eax -16565 # . epilogue -16566 89/<- %esp 5/r32/ebp -16567 5d/pop-to-ebp -16568 c3/return -16569 -16570 $add-operation-and-inputs-to-stmt:abort: -16571 # error("fn ___: invalid identifier in '" line "'\n") -16572 (write-buffered *(ebp+0x18) "fn ") -16573 8b/-> *(ebp+0x14) 0/r32/eax -16574 (lookup *eax *(eax+4)) # Function-name Function-name => eax -16575 (write-buffered *(ebp+0x18) %eax) -16576 (rewind-stream *(ebp+0xc)) -16577 (write-buffered *(ebp+0x18) ": invalid identifier in '") -16578 (write-stream-data *(ebp+0x18) *(ebp+0xc)) -16579 (write-buffered *(ebp+0x18) "'\n") -16580 (flush *(ebp+0x18)) -16581 (stop *(ebp+0x1c) 1) -16582 # never gets here -16583 -16584 $add-operation-and-inputs-to-stmt:error-deref-on-stack: -16585 # error("fn ___: cannot dereference var ___ on stack\n") -16586 (write-buffered *(ebp+0x18) "fn ") -16587 8b/-> *(ebp+0x14) 0/r32/eax -16588 (lookup *eax *(eax+4)) # Function-name Function-name => eax -16589 (write-buffered *(ebp+0x18) %eax) -16590 (rewind-stream *(ebp+0xc)) -16591 (write-buffered *(ebp+0x18) ": cannot dereference var '") -16592 (lookup *esi *(esi+4)) # => eax -16593 (lookup *eax *(eax+4)) # Var-name Var-name => eax -16594 (write-buffered *(ebp+0x18) %eax) -16595 (write-buffered *(ebp+0x18) "' on stack\n") -16596 (flush *(ebp+0x18)) -16597 (stop *(ebp+0x1c) 1) -16598 # never gets here -16599 -16600 $add-operation-and-inputs-to-stmt:error-deref-non-addr: -16601 # error("fn ___: cannot dereference non-addr var ___\n") -16602 (write-buffered *(ebp+0x18) "fn ") -16603 8b/-> *(ebp+0x14) 0/r32/eax -16604 (lookup *eax *(eax+4)) # Function-name Function-name => eax -16605 (write-buffered *(ebp+0x18) %eax) -16606 (rewind-stream *(ebp+0xc)) -16607 (write-buffered *(ebp+0x18) ": cannot dereference non-addr var '") -16608 (lookup *esi *(esi+4)) # => eax -16609 (lookup *eax *(eax+4)) # Var-name Var-name => eax -16610 (write-buffered *(ebp+0x18) %eax) -16611 (write-buffered *(ebp+0x18) "'\n") -16612 (flush *(ebp+0x18)) -16613 (stop *(ebp+0x1c) 1) -16614 # never gets here -16615 -16616 stmt-has-outputs?: # line: (addr stream byte) -> result/eax: boolean -16617 # . prologue -16618 55/push-ebp -16619 89/<- %ebp 4/r32/esp -16620 # . save registers -16621 51/push-ecx -16622 # var word-slice/ecx: slice -16623 68/push 0/imm32/end -16624 68/push 0/imm32/start -16625 89/<- %ecx 4/r32/esp -16626 # result = false -16627 b8/copy-to-eax 0/imm32/false -16628 (rewind-stream *(ebp+8)) -16629 { -16630 (next-mu-token *(ebp+8) %ecx) -16631 # if slice-empty?(word-slice) break -16632 (slice-empty? %ecx) -16633 3d/compare-eax-and 0/imm32/false -16634 b8/copy-to-eax 0/imm32/false/result # restore result (if we're here it's still false) -16635 0f 85/jump-if-!= break/disp32 -16636 # if slice-starts-with?(word-slice, '#') break -16637 # . eax = *word-slice->start -16638 8b/-> *ecx 0/r32/eax -16639 8a/copy-byte *eax 0/r32/AL -16640 81 4/subop/and %eax 0xff/imm32 -16641 # . if (eax == '#') break -16642 3d/compare-eax-and 0x23/imm32/hash -16643 b8/copy-to-eax 0/imm32/false/result # restore result (if we're here it's still false) -16644 0f 84/jump-if-= break/disp32 -16645 # if slice-equal?(word-slice, '<-') return true -16646 (slice-equal? %ecx "<-") -16647 3d/compare-eax-and 0/imm32/false -16648 74/jump-if-= loop/disp8 -16649 b8/copy-to-eax 1/imm32/true -16650 } -16651 $stmt-has-outputs:end: -16652 (rewind-stream *(ebp+8)) -16653 # . reclaim locals -16654 81 0/subop/add %esp 8/imm32 -16655 # . restore registers -16656 59/pop-to-ecx -16657 # . epilogue -16658 89/<- %esp 5/r32/ebp -16659 5d/pop-to-ebp -16660 c3/return -16661 -16662 # if 'name' starts with a digit, create a new literal var for it -16663 # otherwise return first 'name' from the top (back) of 'vars' and abort if not found -16664 lookup-var-or-literal: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -16665 # . prologue -16666 55/push-ebp -16667 89/<- %ebp 4/r32/esp -16668 # . save registers -16669 50/push-eax -16670 51/push-ecx -16671 56/push-esi -16672 # esi = name -16673 8b/-> *(ebp+8) 6/r32/esi -16674 # if slice-empty?(name) abort -16675 (slice-empty? %esi) # => eax -16676 3d/compare-eax-and 0/imm32/false -16677 0f 85/jump-if-!= $lookup-var-or-literal:abort/disp32 -16678 # var c/ecx: byte = *name->start -16679 8b/-> *esi 1/r32/ecx -16680 8a/copy-byte *ecx 1/r32/CL -16681 81 4/subop/and %ecx 0xff/imm32 -16682 # if (is-decimal-digit?(c) || c == '-') return new var(name) -16683 { -16684 81 7/subop/compare %ecx 0x2d/imm32/dash -16685 74/jump-if-= $lookup-var-or-literal:literal/disp8 -16686 (is-decimal-digit? %ecx) # => eax -16687 3d/compare-eax-and 0/imm32/false -16688 74/jump-if-= break/disp8 -16689 $lookup-var-or-literal:literal: -16690 (new-literal-integer Heap %esi *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -16691 eb/jump $lookup-var-or-literal:end/disp8 -16692 } -16693 # else if (c == '"') return new var(name) -16694 { -16695 81 7/subop/compare %ecx 0x22/imm32/dquote -16696 75/jump-if-!= break/disp8 -16697 $lookup-var-or-literal:literal-string: -16698 (new-literal-string Heap %esi *(ebp+0x10)) -16699 eb/jump $lookup-var-or-literal:end/disp8 -16700 } -16701 # otherwise return lookup-var(name, vars) -16702 { -16703 $lookup-var-or-literal:var: -16704 (lookup-var %esi *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -16705 } -16706 $lookup-var-or-literal:end: -16707 # . restore registers -16708 5e/pop-to-esi -16709 59/pop-to-ecx -16710 58/pop-to-eax -16711 # . epilogue -16712 89/<- %esp 5/r32/ebp -16713 5d/pop-to-ebp -16714 c3/return -16715 -16716 $lookup-var-or-literal:abort: -16717 (write-buffered *(ebp+0x18) "fn ") -16718 8b/-> *(ebp+0x14) 0/r32/eax -16719 (lookup *eax *(eax+4)) # Function-name Function-name => eax -16720 (write-buffered *(ebp+0x18) %eax) -16721 (write-buffered *(ebp+0x18) ": empty variable!") -16722 (flush *(ebp+0x18)) -16723 (stop *(ebp+0x1c) 1) -16724 # never gets here -16725 -16726 # return first 'name' from the top (back) of 'vars' and abort if not found -16727 lookup-var: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -16728 # . prologue -16729 55/push-ebp -16730 89/<- %ebp 4/r32/esp -16731 # . save registers -16732 50/push-eax -16733 # -16734 (lookup-var-helper *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -16735 # if (*out == 0) abort -16736 8b/-> *(ebp+0x10) 0/r32/eax -16737 81 7/subop/compare *eax 0/imm32 -16738 74/jump-if-= $lookup-var:abort/disp8 -16739 $lookup-var:end: -16740 # . restore registers -16741 58/pop-to-eax -16742 # . epilogue -16743 89/<- %esp 5/r32/ebp -16744 5d/pop-to-ebp -16745 c3/return -16746 -16747 $lookup-var:abort: -16748 (write-buffered *(ebp+0x18) "fn ") -16749 8b/-> *(ebp+0x14) 0/r32/eax -16750 (lookup *eax *(eax+4)) # Function-name Function-name => eax -16751 (write-buffered *(ebp+0x18) %eax) -16752 (write-buffered *(ebp+0x18) ": unknown variable '") -16753 (write-slice-buffered *(ebp+0x18) *(ebp+8)) -16754 (write-buffered *(ebp+0x18) "'\n") -16755 (flush *(ebp+0x18)) -16756 (stop *(ebp+0x1c) 1) -16757 # never gets here -16758 -16759 # return first 'name' from the top (back) of 'vars', and 0/null if not found -16760 # ensure that 'name' if in a register is the topmost variable in that register -16761 lookup-var-helper: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -16762 # pseudocode: -16763 # var curr: (addr handle var) = &vars->data[vars->top - 12] -16764 # var min = vars->data -16765 # while curr >= min -16766 # var v: (handle var) = *curr -16767 # if v->name == name -16768 # return -16769 # curr -= 12 -16770 # -16771 # . prologue -16772 55/push-ebp -16773 89/<- %ebp 4/r32/esp -16774 # . save registers -16775 50/push-eax -16776 51/push-ecx -16777 52/push-edx -16778 53/push-ebx -16779 56/push-esi -16780 57/push-edi -16781 # clear out -16782 (zero-out *(ebp+0x10) *Handle-size) -16783 # esi = vars -16784 8b/-> *(ebp+0xc) 6/r32/esi -16785 # ebx = vars->top -16786 8b/-> *esi 3/r32/ebx -16787 # if (vars->top > vars->size) abort -16788 3b/compare<- *(esi+4) 0/r32/eax -16789 0f 8f/jump-if-> $lookup-var-helper:error1/disp32 -16790 # var min/edx: (addr handle var) = vars->data -16791 8d/copy-address *(esi+8) 2/r32/edx -16792 # var curr/ebx: (addr handle var) = &vars->data[vars->top - 12] -16793 8d/copy-address *(esi+ebx-4) 3/r32/ebx # vars + 8 + vars->type - 12 -16794 # var var-in-reg/edi: 16 addrs -16795 68/push 0/imm32 -16796 68/push 0/imm32 -16797 68/push 0/imm32 -16798 68/push 0/imm32 -16799 68/push 0/imm32 -16800 68/push 0/imm32 -16801 68/push 0/imm32 -16802 68/push 0/imm32 -16803 68/push 0/imm32 -16804 68/push 0/imm32 -16805 68/push 0/imm32 -16806 68/push 0/imm32 -16807 68/push 0/imm32 -16808 68/push 0/imm32 -16809 68/push 0/imm32 -16810 68/push 0/imm32 -16811 89/<- %edi 4/r32/esp -16812 { -16813 $lookup-var-helper:loop: -16814 # if (curr < min) return -16815 39/compare %ebx 2/r32/edx -16816 0f 82/jump-if-addr< break/disp32 -16817 # var v/ecx: (addr var) = lookup(*curr) -16818 (lookup *ebx *(ebx+4)) # => eax -16819 89/<- %ecx 0/r32/eax -16820 # var vn/eax: (addr array byte) = lookup(v->name) -16821 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -16822 # if (vn == name) return curr -16823 (slice-equal? *(ebp+8) %eax) # => eax -16824 3d/compare-eax-and 0/imm32/false -16825 { -16826 74/jump-if-= break/disp8 -16827 $lookup-var-helper:found: -16828 # var vr/eax: (addr array byte) = lookup(v->register) -16829 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax -16830 3d/compare-eax-and 0/imm32 -16831 { -16832 74/jump-if-= break/disp8 -16833 $lookup-var-helper:found-register: -16834 # var reg/eax: int = get(Registers, vr) -16835 (get Mu-registers-unique %eax 0xc "Mu-registers-unique") # => eax -16836 8b/-> *eax 0/r32/eax -16837 # if (var-in-reg[reg]) error -16838 8b/-> *(edi+eax<<2) 0/r32/eax -16839 3d/compare-eax-and 0/imm32 -16840 0f 85/jump-if-!= $lookup-var-helper:error2/disp32 -16841 } -16842 $lookup-var-helper:return: -16843 # esi = out -16844 8b/-> *(ebp+0x10) 6/r32/esi -16845 # *out = *curr -16846 8b/-> *ebx 0/r32/eax -16847 89/<- *esi 0/r32/eax -16848 8b/-> *(ebx+4) 0/r32/eax -16849 89/<- *(esi+4) 0/r32/eax -16850 # return -16851 eb/jump $lookup-var-helper:end/disp8 -16852 } -16853 # 'name' not yet found; update var-in-reg if v in register -16854 # . var vr/eax: (addr array byte) = lookup(v->register) -16855 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax -16856 # . if (vr == 0) continue -16857 3d/compare-eax-and 0/imm32 -16858 74/jump-if-= $lookup-var-helper:continue/disp8 -16859 # . var reg/eax: int = get(Registers, vr) -16860 (get Mu-registers-unique %eax 0xc "Mu-registers-unique") # => eax -16861 8b/-> *eax 0/r32/eax -16862 # . var-in-reg[reg] = v -16863 89/<- *(edi+eax<<2) 1/r32/ecx -16864 $lookup-var-helper:continue: -16865 # curr -= 12 -16866 81 5/subop/subtract %ebx 0xc/imm32 -16867 e9/jump loop/disp32 -16868 } -16869 $lookup-var-helper:end: -16870 # . reclaim locals -16871 81 0/subop/add %esp 0x40/imm32 -16872 # . restore registers -16873 5f/pop-to-edi -16874 5e/pop-to-esi -16875 5b/pop-to-ebx -16876 5a/pop-to-edx -16877 59/pop-to-ecx -16878 58/pop-to-eax -16879 # . epilogue -16880 89/<- %esp 5/r32/ebp -16881 5d/pop-to-ebp -16882 c3/return -16883 -16884 $lookup-var-helper:error1: -16885 (write-buffered *(ebp+0x18) "fn ") -16886 8b/-> *(ebp+0x14) 0/r32/eax -16887 (lookup *eax *(eax+4)) # Function-name Function-name => eax -16888 (write-buffered *(ebp+0x18) %eax) -16889 (write-buffered *(ebp+0x18) ": malformed stack when looking up '") -16890 (write-slice-buffered *(ebp+0x18) *(ebp+8)) -16891 (write-buffered *(ebp+0x18) "'\n") -16892 (flush *(ebp+0x18)) -16893 (stop *(ebp+0x1c) 1) -16894 # never gets here -16895 -16896 $lookup-var-helper:error2: -16897 # eax contains the conflicting var at this point -16898 (write-buffered *(ebp+0x18) "fn ") -16899 50/push-eax -16900 8b/-> *(ebp+0x14) 0/r32/eax -16901 (lookup *eax *(eax+4)) # Function-name Function-name => eax -16902 (write-buffered *(ebp+0x18) %eax) -16903 58/pop-eax -16904 (write-buffered *(ebp+0x18) ": register ") -16905 50/push-eax -16906 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -16907 (write-buffered *(ebp+0x18) %eax) -16908 58/pop-to-eax -16909 (write-buffered *(ebp+0x18) " reads var '") -16910 (write-slice-buffered *(ebp+0x18) *(ebp+8)) -16911 (write-buffered *(ebp+0x18) "' after writing var '") -16912 (lookup *eax *(eax+4)) # Var-name Var-name => eax -16913 (write-buffered *(ebp+0x18) %eax) -16914 (write-buffered *(ebp+0x18) "'\n") -16915 (flush *(ebp+0x18)) -16916 (stop *(ebp+0x1c) 1) -16917 # never gets here -16918 -16919 dump-vars: # vars: (addr stack live-var) -16920 # pseudocode: -16921 # var curr: (addr handle var) = &vars->data[vars->top - 12] -16922 # var min = vars->data -16923 # while curr >= min -16924 # var v: (handle var) = *curr -16925 # print v -16926 # curr -= 12 -16927 # -16928 # . prologue -16929 55/push-ebp -16930 89/<- %ebp 4/r32/esp -16931 # . save registers -16932 52/push-edx -16933 53/push-ebx -16934 56/push-esi -16935 # esi = vars -16936 8b/-> *(ebp+8) 6/r32/esi -16937 # ebx = vars->top -16938 8b/-> *esi 3/r32/ebx -16939 # var min/edx: (addr handle var) = vars->data -16940 8d/copy-address *(esi+8) 2/r32/edx -16941 # var curr/ebx: (addr handle var) = &vars->data[vars->top - 12] -16942 8d/copy-address *(esi+ebx-4) 3/r32/ebx # vars + 8 + vars->type - 12 -16943 { -16944 $dump-vars:loop: -16945 # if (curr < min) return -16946 39/compare %ebx 2/r32/edx -16947 0f 82/jump-if-addr< break/disp32 -16948 # -16949 (write-buffered Stderr " var@") -16950 (dump-var 2 %ebx) -16951 # curr -= 12 -16952 81 5/subop/subtract %ebx 0xc/imm32 -16953 e9/jump loop/disp32 -16954 } -16955 $dump-vars:end: -16956 # . restore registers -16957 5e/pop-to-esi -16958 5b/pop-to-ebx -16959 5a/pop-to-edx -16960 # . epilogue -16961 89/<- %esp 5/r32/ebp -16962 5d/pop-to-ebp -16963 c3/return -16964 -16965 == data -16966 # Like Registers, but no esp or ebp -16967 Mu-registers: # (addr stream {(handle array byte), int}) -16968 # a table is a stream -16969 0xa8/imm32/write -16970 0/imm32/read -16971 0xa8/imm32/length -16972 # data -16973 # general-purpose registers -16974 # it is perfectly ok to use fake alloc-ids -- as long as you never try to reclaim them -16975 0x11/imm32/alloc-id $Mu-register-eax/imm32 0/imm32 -16976 0x11/imm32/alloc-id $Mu-register-ecx/imm32 1/imm32 -16977 0x11/imm32/alloc-id $Mu-register-edx/imm32 2/imm32 -16978 0x11/imm32/alloc-id $Mu-register-ebx/imm32 3/imm32 -16979 0x11/imm32/alloc-id $Mu-register-esi/imm32 6/imm32 -16980 0x11/imm32/alloc-id $Mu-register-edi/imm32 7/imm32 -16981 # floating-point registers -16982 0x11/imm32/alloc-id $Mu-register-xmm0/imm32 0/imm32 -16983 0x11/imm32/alloc-id $Mu-register-xmm1/imm32 1/imm32 -16984 0x11/imm32/alloc-id $Mu-register-xmm2/imm32 2/imm32 -16985 0x11/imm32/alloc-id $Mu-register-xmm3/imm32 3/imm32 -16986 0x11/imm32/alloc-id $Mu-register-xmm4/imm32 4/imm32 -16987 0x11/imm32/alloc-id $Mu-register-xmm5/imm32 5/imm32 -16988 0x11/imm32/alloc-id $Mu-register-xmm6/imm32 6/imm32 -16989 0x11/imm32/alloc-id $Mu-register-xmm7/imm32 7/imm32 -16990 -16991 # Like Mu-registers, but with unique codes for integer and floating-point -16992 # registers. -16993 # Don't use this for code-generation, only for checking. -16994 Mu-registers-unique: # (addr stream {(handle array byte), int}) -16995 # a table is a stream -16996 0xa8/imm32/write -16997 0/imm32/read -16998 0xa8/imm32/length -16999 # data -17000 # general-purpose registers -17001 0x11/imm32/alloc-id $Mu-register-eax/imm32 0/imm32 -17002 0x11/imm32/alloc-id $Mu-register-ecx/imm32 1/imm32 -17003 0x11/imm32/alloc-id $Mu-register-edx/imm32 2/imm32 -17004 0x11/imm32/alloc-id $Mu-register-ebx/imm32 3/imm32 -17005 0x11/imm32/alloc-id $Mu-register-esi/imm32 6/imm32 -17006 0x11/imm32/alloc-id $Mu-register-edi/imm32 7/imm32 -17007 # floating-point registers -17008 0x11/imm32/alloc-id $Mu-register-xmm0/imm32 8/imm32 -17009 0x11/imm32/alloc-id $Mu-register-xmm1/imm32 9/imm32 -17010 0x11/imm32/alloc-id $Mu-register-xmm2/imm32 0xa/imm32 -17011 0x11/imm32/alloc-id $Mu-register-xmm3/imm32 0xb/imm32 -17012 0x11/imm32/alloc-id $Mu-register-xmm4/imm32 0xc/imm32 -17013 0x11/imm32/alloc-id $Mu-register-xmm5/imm32 0xd/imm32 -17014 0x11/imm32/alloc-id $Mu-register-xmm6/imm32 0xe/imm32 -17015 0x11/imm32/alloc-id $Mu-register-xmm7/imm32 0xf/imm32 -17016 -17017 $Mu-register-eax: -17018 0x11/imm32/alloc-id -17019 3/imm32/size -17020 0x65/e 0x61/a 0x78/x -17021 -17022 $Mu-register-ecx: -17023 0x11/imm32/alloc-id -17024 3/imm32/size -17025 0x65/e 0x63/c 0x78/x -17026 -17027 $Mu-register-edx: -17028 0x11/imm32/alloc-id -17029 3/imm32/size -17030 0x65/e 0x64/d 0x78/x -17031 -17032 $Mu-register-ebx: -17033 0x11/imm32/alloc-id -17034 3/imm32/size -17035 0x65/e 0x62/b 0x78/x -17036 -17037 $Mu-register-esi: -17038 0x11/imm32/alloc-id -17039 3/imm32/size -17040 0x65/e 0x73/s 0x69/i -17041 -17042 $Mu-register-edi: -17043 0x11/imm32/alloc-id -17044 3/imm32/size -17045 0x65/e 0x64/d 0x69/i -17046 -17047 $Mu-register-xmm0: -17048 0x11/imm32/alloc-id:fake:payload -17049 # "xmm0" -17050 0x4/imm32/size -17051 0x78/x 0x6d/m 0x6d/m 0x30/0 -17052 -17053 $Mu-register-xmm1: -17054 0x11/imm32/alloc-id:fake:payload -17055 # "xmm1" -17056 0x4/imm32/size -17057 0x78/x 0x6d/m 0x6d/m 0x31/1 -17058 -17059 $Mu-register-xmm2: -17060 0x11/imm32/alloc-id:fake:payload -17061 # "xmm2" -17062 0x4/imm32/size -17063 0x78/x 0x6d/m 0x6d/m 0x32/2 -17064 -17065 $Mu-register-xmm3: -17066 0x11/imm32/alloc-id:fake:payload -17067 # "xmm3" -17068 0x4/imm32/size -17069 0x78/x 0x6d/m 0x6d/m 0x33/3 -17070 -17071 $Mu-register-xmm4: -17072 0x11/imm32/alloc-id:fake:payload -17073 # "xmm4" -17074 0x4/imm32/size -17075 0x78/x 0x6d/m 0x6d/m 0x34/4 -17076 -17077 $Mu-register-xmm5: -17078 0x11/imm32/alloc-id:fake:payload -17079 # "xmm5" -17080 0x4/imm32/size -17081 0x78/x 0x6d/m 0x6d/m 0x35/5 -17082 -17083 $Mu-register-xmm6: -17084 0x11/imm32/alloc-id:fake:payload -17085 # "xmm6" -17086 0x4/imm32/size -17087 0x78/x 0x6d/m 0x6d/m 0x36/6 -17088 -17089 $Mu-register-xmm7: -17090 0x11/imm32/alloc-id:fake:payload -17091 # "xmm7" -17092 0x4/imm32/size -17093 0x78/x 0x6d/m 0x6d/m 0x37/7 -17094 -17095 == code -17096 -17097 # push 'out' to 'vars' if not already there; it's assumed to be a fn output -17098 maybe-define-var: # out: (handle var), vars: (addr stack live-var) -17099 # . prologue -17100 55/push-ebp -17101 89/<- %ebp 4/r32/esp -17102 # . save registers -17103 50/push-eax -17104 # var out-addr/eax: (addr var) -17105 (lookup *(ebp+8) *(ebp+0xc)) # => eax -17106 # -17107 (binding-exists? %eax *(ebp+0x10)) # => eax -17108 3d/compare-eax-and 0/imm32/false -17109 75/jump-if-!= $maybe-define-var:end/disp8 -17110 # otherwise update vars -17111 (push *(ebp+0x10) *(ebp+8)) -17112 (push *(ebp+0x10) *(ebp+0xc)) -17113 (push *(ebp+0x10) 0) # 'out' is always a fn output; never spill it -17114 $maybe-define-var:end: -17115 # . restore registers -17116 58/pop-to-eax -17117 # . epilogue -17118 89/<- %esp 5/r32/ebp -17119 5d/pop-to-ebp -17120 c3/return -17121 -17122 # simpler version of lookup-var-helper -17123 binding-exists?: # target: (addr var), vars: (addr stack live-var) -> result/eax: boolean -17124 # pseudocode: -17125 # var curr: (addr handle var) = &vars->data[vars->top - 12] -17126 # var min = vars->data -17127 # while curr >= min -17128 # var v: (handle var) = *curr -17129 # if v->name == target->name -17130 # return true -17131 # curr -= 12 -17132 # return false -17133 # -17134 # . prologue -17135 55/push-ebp -17136 89/<- %ebp 4/r32/esp -17137 # . save registers -17138 51/push-ecx -17139 52/push-edx -17140 56/push-esi -17141 # var target-name/ecx: (addr array byte) = lookup(target->name) -17142 8b/-> *(ebp+8) 0/r32/eax -17143 (lookup *eax *(eax+4)) # Var-name Var-name => eax -17144 89/<- %ecx 0/r32/eax -17145 # esi = vars -17146 8b/-> *(ebp+0xc) 6/r32/esi -17147 # eax = vars->top -17148 8b/-> *esi 0/r32/eax -17149 # var min/edx: (addr handle var) = vars->data -17150 8d/copy-address *(esi+8) 2/r32/edx -17151 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] -17152 8d/copy-address *(esi+eax-4) 6/r32/esi # vars + 8 + vars->type - 12 -17153 { -17154 $binding-exists?:loop: -17155 # if (curr < min) return -17156 39/compare %esi 2/r32/edx -17157 0f 82/jump-if-addr< break/disp32 -17158 # var v/eax: (addr var) = lookup(*curr) -17159 (lookup *esi *(esi+4)) # => eax -17160 # var vn/eax: (addr array byte) = lookup(v->name) -17161 (lookup *eax *(eax+4)) # Var-name Var-name => eax -17162 # if (vn == target-name) return true -17163 (string-equal? %ecx %eax) # => eax -17164 3d/compare-eax-and 0/imm32/false -17165 75/jump-if-!= $binding-exists?:end/disp8 # eax already contains true -17166 # curr -= 12 -17167 81 5/subop/subtract %esi 0xc/imm32 -17168 e9/jump loop/disp32 -17169 } -17170 b8/copy-to-eax 0/imm32/false -17171 $binding-exists?:end: -17172 # . restore registers -17173 5e/pop-to-esi -17174 5a/pop-to-edx -17175 59/pop-to-ecx -17176 # . epilogue -17177 89/<- %esp 5/r32/ebp -17178 5d/pop-to-ebp -17179 c3/return -17180 -17181 test-parse-mu-stmt: -17182 # . prologue -17183 55/push-ebp -17184 89/<- %ebp 4/r32/esp -17185 # setup -17186 8b/-> *Primitive-type-ids 0/r32/eax -17187 89/<- *Type-id 0/r32/eax # stream-write -17188 (clear-stream _test-input-stream) -17189 (write _test-input-stream "increment n\n") -17190 # var vars/ecx: (stack (addr var) 16) -17191 81 5/subop/subtract %esp 0xc0/imm32 -17192 68/push 0xc0/imm32/size -17193 68/push 0/imm32/top -17194 89/<- %ecx 4/r32/esp -17195 (clear-stack %ecx) -17196 # var v/edx: (handle var) -17197 68/push 0/imm32 -17198 68/push 0/imm32 -17199 89/<- %edx 4/r32/esp -17200 # var s/eax: (handle array byte) -17201 68/push 0/imm32 -17202 68/push 0/imm32 -17203 89/<- %eax 4/r32/esp -17204 # v = new var("n") -17205 (copy-array Heap "n" %eax) -17206 (new-var Heap *eax *(eax+4) %edx) -17207 # -17208 (push %ecx *edx) -17209 (push %ecx *(edx+4)) -17210 (push %ecx 0) -17211 # var out/eax: (handle stmt) -17212 68/push 0/imm32 -17213 68/push 0/imm32 -17214 89/<- %eax 4/r32/esp -17215 # convert -17216 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0) -17217 # var out-addr/edx: (addr stmt) = lookup(*out) -17218 (lookup *eax *(eax+4)) # => eax -17219 89/<- %edx 0/r32/eax -17220 # out->tag -17221 (check-ints-equal *edx 1 "F - test-parse-mu-stmt/tag") # Stmt-tag is Stmt1 -17222 # out->operation -17223 (lookup *(edx+4) *(edx+8)) # Stmt1-operation Stmt1-operation => eax -17224 (check-strings-equal %eax "increment" "F - test-parse-mu-stmt/name") # Stmt1-operation -17225 # out->inouts->value->name -17226 # . eax = out->inouts -17227 (lookup *(edx+0xc) *(edx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -17228 # . eax = out->inouts->value -17229 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -17230 # . eax = out->inouts->value->name -17231 (lookup *eax *(eax+4)) # Var-name Var-name => eax -17232 # . -17233 (check-strings-equal %eax "n" "F - test-parse-mu-stmt/inout:0") -17234 # . epilogue -17235 89/<- %esp 5/r32/ebp -17236 5d/pop-to-ebp -17237 c3/return -17238 -17239 test-parse-mu-stmt-with-comma: -17240 # . prologue -17241 55/push-ebp -17242 89/<- %ebp 4/r32/esp -17243 # setup -17244 8b/-> *Primitive-type-ids 0/r32/eax -17245 89/<- *Type-id 0/r32/eax # stream-write -17246 (clear-stream _test-input-stream) -17247 (write _test-input-stream "copy-to n, 3\n") -17248 # var vars/ecx: (stack (addr var) 16) -17249 81 5/subop/subtract %esp 0xc0/imm32 -17250 68/push 0xc0/imm32/size -17251 68/push 0/imm32/top -17252 89/<- %ecx 4/r32/esp -17253 (clear-stack %ecx) -17254 # var v/edx: (handle var) -17255 68/push 0/imm32 -17256 68/push 0/imm32 -17257 89/<- %edx 4/r32/esp -17258 # var s/eax: (handle array byte) -17259 68/push 0/imm32 -17260 68/push 0/imm32 -17261 89/<- %eax 4/r32/esp -17262 # v = new var("n") -17263 (copy-array Heap "n" %eax) -17264 (new-var Heap *eax *(eax+4) %edx) -17265 # -17266 (push %ecx *edx) -17267 (push %ecx *(edx+4)) -17268 (push %ecx 0) -17269 # var out/eax: (handle stmt) -17270 68/push 0/imm32 -17271 68/push 0/imm32 -17272 89/<- %eax 4/r32/esp -17273 # convert -17274 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0) -17275 # var out-addr/edx: (addr stmt) = lookup(*out) -17276 (lookup *eax *(eax+4)) # => eax -17277 89/<- %edx 0/r32/eax -17278 # out->tag -17279 (check-ints-equal *edx 1 "F - test-parse-mu-stmt-with-comma/tag") # Stmt-tag is Stmt1 -17280 # out->operation -17281 (lookup *(edx+4) *(edx+8)) # Stmt1-operation Stmt1-operation => eax -17282 (check-strings-equal %eax "copy-to" "F - test-parse-mu-stmt-with-comma/name") # Stmt1-operation -17283 # out->inouts->value->name -17284 # . eax = out->inouts -17285 (lookup *(edx+0xc) *(edx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -17286 # . eax = out->inouts->value -17287 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -17288 # . eax = out->inouts->value->name -17289 (lookup *eax *(eax+4)) # Var-name Var-name => eax -17290 # . -17291 (check-strings-equal %eax "n" "F - test-parse-mu-stmt-with-comma/inout:0") -17292 # . epilogue -17293 89/<- %esp 5/r32/ebp -17294 5d/pop-to-ebp -17295 c3/return -17296 -17297 new-var: # ad: (addr allocation-descriptor), name: (handle array byte), out: (addr handle var) -17298 # . prologue -17299 55/push-ebp -17300 89/<- %ebp 4/r32/esp -17301 # . save registers -17302 50/push-eax -17303 51/push-ecx -17304 # ecx = out -17305 8b/-> *(ebp+0x14) 1/r32/ecx -17306 # -17307 (allocate *(ebp+8) *Var-size %ecx) -17308 # var out-addr/eax: (addr var) -17309 (lookup *ecx *(ecx+4)) # => eax -17310 # out-addr->name = name -17311 8b/-> *(ebp+0xc) 1/r32/ecx -17312 89/<- *eax 1/r32/ecx # Var-name -17313 8b/-> *(ebp+0x10) 1/r32/ecx -17314 89/<- *(eax+4) 1/r32/ecx # Var-name -17315 #? (write-buffered Stderr "var ") -17316 #? (lookup *(ebp+0xc) *(ebp+0x10)) -17317 #? (write-buffered Stderr %eax) -17318 #? (write-buffered Stderr " at ") -17319 #? 8b/-> *(ebp+0x14) 1/r32/ecx -17320 #? (lookup *ecx *(ecx+4)) # => eax -17321 #? (write-int32-hex-buffered Stderr %eax) -17322 #? (write-buffered Stderr Newline) -17323 #? (flush Stderr) -17324 $new-var:end: -17325 # . restore registers -17326 59/pop-to-ecx -17327 58/pop-to-eax -17328 # . epilogue -17329 89/<- %esp 5/r32/ebp -17330 5d/pop-to-ebp -17331 c3/return -17332 -17333 new-literal-integer: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -17334 # . prologue -17335 55/push-ebp -17336 89/<- %ebp 4/r32/esp -17337 # . save registers -17338 50/push-eax -17339 51/push-ecx -17340 # if (!is-hex-int?(name)) abort -17341 (is-hex-int? *(ebp+0xc)) # => eax -17342 3d/compare-eax-and 0/imm32/false -17343 0f 84/jump-if-= $new-literal-integer:abort/disp32 -17344 # a little more error-checking -17345 (check-mu-hex-int *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c)) -17346 # out = new var(s) -17347 (new-var-from-slice *(ebp+8) *(ebp+0xc) *(ebp+0x10)) -17348 # var out-addr/ecx: (addr var) = lookup(*out) -17349 8b/-> *(ebp+0x10) 0/r32/eax -17350 (lookup *eax *(eax+4)) # => eax -17351 89/<- %ecx 0/r32/eax -17352 # out-addr->block-depth = *Curr-block-depth -17353 8b/-> *Curr-block-depth 0/r32/eax -17354 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth -17355 # out-addr->type = new tree() -17356 8d/copy-address *(ecx+8) 0/r32/eax # Var-type -17357 (allocate *(ebp+8) *Type-tree-size %eax) -17358 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -17359 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom -17360 # nothing else to do; default type is 'literal' -17361 $new-literal-integer:end: -17362 # . reclaim locals -17363 81 0/subop/add %esp 8/imm32 -17364 # . restore registers -17365 59/pop-to-ecx -17366 58/pop-to-eax -17367 # . epilogue -17368 89/<- %esp 5/r32/ebp -17369 5d/pop-to-ebp -17370 c3/return -17371 -17372 $new-literal-integer:abort: -17373 (write-buffered *(ebp+0x18) "fn ") -17374 8b/-> *(ebp+0x14) 0/r32/eax -17375 (lookup *eax *(eax+4)) # Function-name Function-name => eax -17376 (write-buffered *(ebp+0x18) %eax) -17377 (write-buffered *(ebp+0x18) ": variable '") -17378 (write-slice-buffered *(ebp+0x18) *(ebp+0xc)) -17379 (write-buffered *(ebp+0x18) "' cannot begin with a digit (or do you have a typo in a number?)\n") -17380 (flush *(ebp+0x18)) -17381 (stop *(ebp+0x1c) 1) -17382 # never gets here -17383 -17384 # precondition: name is a valid hex integer; require a '0x' prefix -17385 check-mu-hex-int: # name: (addr slice), err: (addr buffered-file), ed: (addr exit-descriptor) -17386 # . prologue -17387 55/push-ebp -17388 89/<- %ebp 4/r32/esp -17389 # . save registers -17390 50/push-eax -17391 51/push-ecx -17392 52/push-edx -17393 # ecx = name -17394 8b/-> *(ebp+8) 1/r32/ecx -17395 # var start/edx: (addr byte) = name->start -17396 8b/-> *ecx 2/r32/edx -17397 # if (*start == '-') ++start -17398 b8/copy-to-eax 0/imm32 -17399 8a/copy-byte *edx 0/r32/AL -17400 3d/compare-eax-and 0x2d/imm32/dash -17401 { -17402 75/jump-if-!= break/disp8 -17403 42/increment-edx -17404 } -17405 # var end/ecx: (addr byte) = name->end -17406 8b/-> *(ecx+4) 1/r32/ecx -17407 # var len/eax: int = name->end - name->start -17408 89/<- %eax 1/r32/ecx -17409 29/subtract-from %eax 2/r32/edx -17410 # if (len <= 1) return -17411 3d/compare-eax-with 1/imm32 -17412 0f 8e/jump-if-<= $check-mu-hex-int:end/disp32 -17413 $check-mu-hex-int:length->-1: -17414 # if slice-starts-with?({start, end}, "0x") return -17415 # . var tmp = {start, end} -17416 51/push-ecx -17417 52/push-edx -17418 89/<- %eax 4/r32/esp -17419 # . -17420 (slice-starts-with? %eax "0x") # => eax -17421 # . reclaim tmp -17422 81 0/subop/add %esp 8/imm32 -17423 # . -17424 3d/compare-eax-with 0/imm32/false -17425 75/jump-if-!= $check-mu-hex-int:end/disp8 -17426 $check-mu-hex-int:abort: -17427 # otherwise abort -17428 (write-buffered *(ebp+0xc) "literal integers are always hex in Mu; start '") -17429 (write-slice-buffered *(ebp+0xc) *(ebp+8)) -17430 (write-buffered *(ebp+0xc) "' with a '0x' to be unambiguous, converting it to hexadecimal as necessary.\n") -17431 (flush *(ebp+0xc)) -17432 (stop *(ebp+0x10) 1) -17433 $check-mu-hex-int:end: -17434 # . restore registers -17435 5a/pop-to-edx -17436 59/pop-to-ecx -17437 58/pop-to-eax -17438 # . epilogue -17439 89/<- %esp 5/r32/ebp -17440 5d/pop-to-ebp -17441 c3/return -17442 -17443 new-literal: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) -17444 # . prologue -17445 55/push-ebp -17446 89/<- %ebp 4/r32/esp -17447 # . save registers -17448 50/push-eax -17449 51/push-ecx -17450 # var s/ecx: (handle array byte) -17451 68/push 0/imm32 -17452 68/push 0/imm32 -17453 89/<- %ecx 4/r32/esp -17454 # s = slice-to-string(name) -17455 (slice-to-string Heap *(ebp+0xc) %ecx) -17456 # allocate to out -17457 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) -17458 # var out-addr/ecx: (addr var) = lookup(*out) -17459 8b/-> *(ebp+0x10) 1/r32/ecx -17460 (lookup *ecx *(ecx+4)) # => eax -17461 89/<- %ecx 0/r32/eax -17462 # out-addr->block-depth = *Curr-block-depth -17463 8b/-> *Curr-block-depth 0/r32/eax -17464 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth -17465 # out-addr->type/eax = new type -17466 8d/copy-address *(ecx+8) 0/r32/eax # Var-type -17467 (allocate *(ebp+8) *Type-tree-size %eax) -17468 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -17469 # nothing else to do; default type is 'literal' -17470 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom -17471 $new-literal:end: -17472 # . reclaim locals -17473 81 0/subop/add %esp 8/imm32 -17474 # . restore registers -17475 59/pop-to-ecx -17476 58/pop-to-eax -17477 # . epilogue -17478 89/<- %esp 5/r32/ebp -17479 5d/pop-to-ebp -17480 c3/return -17481 -17482 new-literal-string: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) -17483 # . prologue -17484 55/push-ebp -17485 89/<- %ebp 4/r32/esp -17486 # . save registers -17487 50/push-eax -17488 51/push-ecx -17489 # var s/ecx: (handle array byte) -17490 68/push 0/imm32 -17491 68/push 0/imm32 -17492 89/<- %ecx 4/r32/esp -17493 # s = slice-to-string(name) -17494 (slice-to-string Heap *(ebp+0xc) %ecx) -17495 # allocate to out -17496 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) -17497 # var out-addr/ecx: (addr var) = lookup(*out) -17498 8b/-> *(ebp+0x10) 1/r32/ecx -17499 (lookup *ecx *(ecx+4)) # => eax -17500 89/<- %ecx 0/r32/eax -17501 # out-addr->block-depth = *Curr-block-depth -17502 8b/-> *Curr-block-depth 0/r32/eax -17503 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth -17504 # out-addr->type/eax = new type -17505 8d/copy-address *(ecx+8) 0/r32/eax # Var-type -17506 (allocate *(ebp+8) *Type-tree-size %eax) -17507 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -17508 # out-addr->type->value = literal-string -17509 c7 0/subop/copy *(eax+4) 0x10/imm32/type-id-string-literal # Type-tree-value -17510 # out-addr->type->is-atom? = true -17511 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom -17512 $new-literal-string:end: -17513 # . reclaim locals -17514 81 0/subop/add %esp 8/imm32 -17515 # . restore registers -17516 59/pop-to-ecx -17517 58/pop-to-eax -17518 # . epilogue -17519 89/<- %esp 5/r32/ebp -17520 5d/pop-to-ebp -17521 c3/return -17522 -17523 new-var-from-slice: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) -17524 # . prologue -17525 55/push-ebp -17526 89/<- %ebp 4/r32/esp -17527 # . save registers -17528 51/push-ecx -17529 # var tmp/ecx: (handle array byte) -17530 68/push 0/imm32 -17531 68/push 0/imm32 -17532 89/<- %ecx 4/r32/esp -17533 # tmp = slice-to-string(name) -17534 (slice-to-string Heap *(ebp+0xc) %ecx) -17535 # out = new-var(tmp) -17536 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) -17537 $new-var-from-slice:end: -17538 # . reclaim locals -17539 81 0/subop/add %esp 8/imm32 -17540 # . restore registers -17541 59/pop-to-ecx -17542 # . epilogue -17543 89/<- %esp 5/r32/ebp -17544 5d/pop-to-ebp -17545 c3/return -17546 -17547 new-var-def: # ad: (addr allocation-descriptor), var: (handle var), out: (addr handle stmt) -17548 # . prologue -17549 55/push-ebp -17550 89/<- %ebp 4/r32/esp -17551 # . save registers -17552 50/push-eax -17553 51/push-ecx -17554 # -17555 (allocate *(ebp+8) *Stmt-size *(ebp+0x14)) -17556 # var out-addr/eax: (addr stmt) = lookup(*out) -17557 8b/-> *(ebp+0x14) 0/r32/eax -17558 (lookup *eax *(eax+4)) # => eax -17559 # out-addr->tag = stmt -17560 c7 0/subop/copy *eax 2/imm32/tag/var-on-stack # Stmt-tag -17561 # result->var = var -17562 8b/-> *(ebp+0xc) 1/r32/ecx -17563 89/<- *(eax+4) 1/r32/ecx # Vardef-var -17564 8b/-> *(ebp+0x10) 1/r32/ecx -17565 89/<- *(eax+8) 1/r32/ecx # Vardef-var -17566 $new-var-def:end: -17567 # . restore registers -17568 59/pop-to-ecx -17569 58/pop-to-eax -17570 # . epilogue -17571 89/<- %esp 5/r32/ebp -17572 5d/pop-to-ebp -17573 c3/return -17574 -17575 new-reg-var-def: # ad: (addr allocation-descriptor), var: (handle var), out: (addr handle stmt) -17576 # . prologue -17577 55/push-ebp -17578 89/<- %ebp 4/r32/esp -17579 # . save registers -17580 50/push-eax -17581 # eax = out -17582 8b/-> *(ebp+0x14) 0/r32/eax -17583 # -17584 (allocate *(ebp+8) *Stmt-size %eax) -17585 # var out-addr/eax: (addr stmt) = lookup(*out) -17586 (lookup *eax *(eax+4)) # => eax -17587 # set tag -17588 c7 0/subop/copy *eax 3/imm32/tag/var-in-register # Stmt-tag -17589 # set output -17590 8d/copy-address *(eax+0x14) 0/r32/eax # Regvardef-outputs -17591 (append-stmt-var Heap *(ebp+0xc) *(ebp+0x10) 0 0 0 %eax) -17592 $new-reg-var-def:end: -17593 # . restore registers +16466 50/push-eax +16467 89/<- %ecx 4/r32/esp +16468 # +16469 (is-identifier? %ecx) +16470 (check-ints-equal %eax 0 "F - test-is-identifier-backtick") +16471 # . epilogue +16472 89/<- %esp 5/r32/ebp +16473 5d/pop-to-ebp +16474 c3/return +16475 +16476 test-is-identifier-curly-brace-open: +16477 # character after 'z' is invalid; also used for blocks +16478 # . prologue +16479 55/push-ebp +16480 89/<- %ebp 4/r32/esp +16481 # (eax..ecx) = "{a" +16482 b8/copy-to-eax "{a"/imm32 +16483 8b/-> *eax 1/r32/ecx +16484 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16485 05/add-to-eax 4/imm32 +16486 # var slice/ecx: slice = {eax, ecx} +16487 51/push-ecx +16488 50/push-eax +16489 89/<- %ecx 4/r32/esp +16490 # +16491 (is-identifier? %ecx) +16492 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-open") +16493 # . epilogue +16494 89/<- %esp 5/r32/ebp +16495 5d/pop-to-ebp +16496 c3/return +16497 +16498 test-is-identifier-curly-brace-close: +16499 # . prologue +16500 55/push-ebp +16501 89/<- %ebp 4/r32/esp +16502 # (eax..ecx) = "}a" +16503 b8/copy-to-eax "}a"/imm32 +16504 8b/-> *eax 1/r32/ecx +16505 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16506 05/add-to-eax 4/imm32 +16507 # var slice/ecx: slice = {eax, ecx} +16508 51/push-ecx +16509 50/push-eax +16510 89/<- %ecx 4/r32/esp +16511 # +16512 (is-identifier? %ecx) +16513 (check-ints-equal %eax 0 "F - test-is-identifier-curly-brace-close") +16514 # . epilogue +16515 89/<- %esp 5/r32/ebp +16516 5d/pop-to-ebp +16517 c3/return +16518 +16519 test-is-identifier-hyphen: +16520 # disallow leading '-' since '->' has special meaning +16521 # . prologue +16522 55/push-ebp +16523 89/<- %ebp 4/r32/esp +16524 # (eax..ecx) = "-a" +16525 b8/copy-to-eax "-a"/imm32 +16526 8b/-> *eax 1/r32/ecx +16527 8d/copy-address *(eax+ecx+4) 1/r32/ecx +16528 05/add-to-eax 4/imm32 +16529 # var slice/ecx: slice = {eax, ecx} +16530 51/push-ecx +16531 50/push-eax +16532 89/<- %ecx 4/r32/esp +16533 # +16534 (is-identifier? %ecx) +16535 (check-ints-equal %eax 0 "F - test-is-identifier-hyphen") +16536 # . epilogue +16537 89/<- %esp 5/r32/ebp +16538 5d/pop-to-ebp +16539 c3/return +16540 +16541 populate-mu-function-body: # in: (addr buffered-file), out: (addr function), vars: (addr stack live-var), err: (addr buffered-file), ed: (addr exit-descriptor) +16542 # . prologue +16543 55/push-ebp +16544 89/<- %ebp 4/r32/esp +16545 # . save registers +16546 50/push-eax +16547 56/push-esi +16548 57/push-edi +16549 # esi = in +16550 8b/-> *(ebp+8) 6/r32/esi +16551 # edi = out +16552 8b/-> *(ebp+0xc) 7/r32/edi +16553 # initialize some global state +16554 c7 0/subop/copy *Curr-block-depth 1/imm32 +16555 # parse-mu-block(in, vars, out, out->body) +16556 8d/copy-address *(edi+0x18) 0/r32/eax # Function-body +16557 (parse-mu-block %esi *(ebp+0x10) %edi %eax *(ebp+0x14) *(ebp+0x18)) +16558 $populate-mu-function-body:end: +16559 # . restore registers +16560 5f/pop-to-edi +16561 5e/pop-to-esi +16562 58/pop-to-eax +16563 # . epilogue +16564 89/<- %esp 5/r32/ebp +16565 5d/pop-to-ebp +16566 c3/return +16567 +16568 # parses a block, assuming that the leading '{' has already been read by the caller +16569 parse-mu-block: # in: (addr buffered-file), vars: (addr stack live-var), fn: (addr function), out: (addr handle block), err: (addr buffered-file), ed: (addr exit-descriptor) +16570 # pseudocode: +16571 # var line: (stream byte 512) +16572 # var word-slice: slice +16573 # allocate(Heap, Stmt-size, out) +16574 # var out-addr: (addr block) = lookup(*out) +16575 # out-addr->tag = 0/block +16576 # out-addr->var = some unique name +16577 # push(vars, {out-addr->var, false}) +16578 # while true # line loop +16579 # clear-stream(line) +16580 # read-line-buffered(in, line) +16581 # if (line->write == 0) break # end of file +16582 # word-slice = next-mu-token(line) +16583 # if slice-empty?(word-slice) # end of line +16584 # continue +16585 # else if slice-starts-with?(word-slice, "#") +16586 # continue +16587 # else if slice-equal?(word-slice, "{") +16588 # assert(no-tokens-in(line)) +16589 # block = parse-mu-block(in, vars, fn) +16590 # append-to-block(out-addr, block) +16591 # else if slice-equal?(word-slice, "}") +16592 # break +16593 # else if slice-ends-with?(word-slice, ":") +16594 # # TODO: error-check the rest of 'line' +16595 # --word-slice->end to skip ':' +16596 # named-block = parse-mu-named-block(word-slice, in, vars, fn) +16597 # append-to-block(out-addr, named-block) +16598 # else if slice-equal?(word-slice, "var") +16599 # var-def = parse-mu-var-def(line, vars, fn) +16600 # append-to-block(out-addr, var-def) +16601 # else +16602 # stmt = parse-mu-stmt(line, vars, fn) +16603 # append-to-block(out-addr, stmt) +16604 # pop(vars) +16605 # +16606 # . prologue +16607 55/push-ebp +16608 89/<- %ebp 4/r32/esp +16609 # . save registers +16610 50/push-eax +16611 51/push-ecx +16612 52/push-edx +16613 53/push-ebx +16614 57/push-edi +16615 # var line/ecx: (stream byte 512) +16616 81 5/subop/subtract %esp 0x200/imm32 +16617 68/push 0x200/imm32/size +16618 68/push 0/imm32/read +16619 68/push 0/imm32/write +16620 89/<- %ecx 4/r32/esp +16621 # var word-slice/edx: slice +16622 68/push 0/imm32/end +16623 68/push 0/imm32/start +16624 89/<- %edx 4/r32/esp +16625 # allocate into out +16626 (allocate Heap *Stmt-size *(ebp+0x14)) +16627 # var out-addr/edi: (addr block) = lookup(*out) +16628 8b/-> *(ebp+0x14) 7/r32/edi +16629 (lookup *edi *(edi+4)) # => eax +16630 89/<- %edi 0/r32/eax +16631 # out-addr->tag is 0 (block) by default +16632 # set out-addr->var +16633 8d/copy-address *(edi+0xc) 0/r32/eax # Block-var +16634 (new-block-name *(ebp+0x10) %eax) +16635 # push(vars, out-addr->var) +16636 (push *(ebp+0xc) *(edi+0xc)) # Block-var +16637 (push *(ebp+0xc) *(edi+0x10)) # Block-var +16638 (push *(ebp+0xc) 0) # false +16639 # increment *Curr-block-depth +16640 ff 0/subop/increment *Curr-block-depth +16641 { +16642 $parse-mu-block:line-loop: +16643 # line = read-line-buffered(in) +16644 (clear-stream %ecx) +16645 (read-line-buffered *(ebp+8) %ecx) +16646 #? (write-buffered Stderr "line: ") +16647 #? (write-stream-data Stderr %ecx) +16648 #? #? (write-buffered Stderr Newline) # line has its own newline +16649 #? (flush Stderr) +16650 #? (rewind-stream %ecx) +16651 # if (line->write == 0) break +16652 81 7/subop/compare *ecx 0/imm32 +16653 0f 84/jump-if-= break/disp32 +16654 #? (write-buffered Stderr "vars:\n") +16655 #? (dump-vars *(ebp+0xc)) +16656 # word-slice = next-mu-token(line) +16657 (next-mu-token %ecx %edx) +16658 #? (write-buffered Stderr "word: ") +16659 #? (write-slice-buffered Stderr %edx) +16660 #? (write-buffered Stderr Newline) +16661 #? (flush Stderr) +16662 # if slice-empty?(word-slice) continue +16663 (slice-empty? %edx) +16664 3d/compare-eax-and 0/imm32/false +16665 0f 85/jump-if-!= loop/disp32 +16666 # if (slice-starts-with?(word-slice, '#') continue +16667 # . eax = *word-slice->start +16668 8b/-> *edx 0/r32/eax +16669 8a/copy-byte *eax 0/r32/AL +16670 81 4/subop/and %eax 0xff/imm32 +16671 # . if (eax == '#') continue +16672 3d/compare-eax-and 0x23/imm32/hash +16673 0f 84/jump-if-= loop/disp32 +16674 # if slice-equal?(word-slice, "{") +16675 { +16676 $parse-mu-block:check-for-block: +16677 (slice-equal? %edx "{") +16678 3d/compare-eax-and 0/imm32/false +16679 74/jump-if-= break/disp8 +16680 (check-no-tokens-left %ecx) +16681 # parse new block and append +16682 # . var tmp/eax: (handle block) +16683 68/push 0/imm32 +16684 68/push 0/imm32 +16685 89/<- %eax 4/r32/esp +16686 # . +16687 (parse-mu-block *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) +16688 (append-to-block Heap %edi *eax *(eax+4)) +16689 # . reclaim tmp +16690 81 0/subop/add %esp 8/imm32 +16691 # . +16692 e9/jump $parse-mu-block:line-loop/disp32 +16693 } +16694 # if slice-equal?(word-slice, "}") break +16695 $parse-mu-block:check-for-end: +16696 (slice-equal? %edx "}") +16697 3d/compare-eax-and 0/imm32/false +16698 0f 85/jump-if-!= break/disp32 +16699 # if slice-ends-with?(word-slice, ":") parse named block and append +16700 { +16701 $parse-mu-block:check-for-named-block: +16702 # . eax = *(word-slice->end-1) +16703 8b/-> *(edx+4) 0/r32/eax +16704 48/decrement-eax +16705 8a/copy-byte *eax 0/r32/AL +16706 81 4/subop/and %eax 0xff/imm32 +16707 # . if (eax != ':') break +16708 3d/compare-eax-and 0x3a/imm32/colon +16709 0f 85/jump-if-!= break/disp32 +16710 # TODO: error-check the rest of 'line' +16711 # +16712 # skip ':' +16713 ff 1/subop/decrement *(edx+4) # Slice-end +16714 # var tmp/eax: (handle block) +16715 68/push 0/imm32 +16716 68/push 0/imm32 +16717 89/<- %eax 4/r32/esp +16718 # +16719 (parse-mu-named-block %edx *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) +16720 (append-to-block Heap %edi *eax *(eax+4)) +16721 # reclaim tmp +16722 81 0/subop/add %esp 8/imm32 +16723 # +16724 e9/jump $parse-mu-block:line-loop/disp32 +16725 } +16726 # if slice-equal?(word-slice, "var") +16727 { +16728 $parse-mu-block:check-for-var: +16729 (slice-equal? %edx "var") +16730 3d/compare-eax-and 0/imm32/false +16731 74/jump-if-= break/disp8 +16732 # var tmp/eax: (handle block) +16733 68/push 0/imm32 +16734 68/push 0/imm32 +16735 89/<- %eax 4/r32/esp +16736 # +16737 (parse-mu-var-def %ecx *(ebp+0xc) %eax *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) +16738 (append-to-block Heap %edi *eax *(eax+4)) +16739 # reclaim tmp +16740 81 0/subop/add %esp 8/imm32 +16741 # +16742 e9/jump $parse-mu-block:line-loop/disp32 +16743 } +16744 $parse-mu-block:regular-stmt: +16745 # otherwise +16746 # var tmp/eax: (handle block) +16747 68/push 0/imm32 +16748 68/push 0/imm32 +16749 89/<- %eax 4/r32/esp +16750 # +16751 (parse-mu-stmt %ecx *(ebp+0xc) *(ebp+0x10) %eax *(ebp+0x18) *(ebp+0x1c)) +16752 (append-to-block Heap %edi *eax *(eax+4)) +16753 # reclaim tmp +16754 81 0/subop/add %esp 8/imm32 +16755 # +16756 e9/jump loop/disp32 +16757 } # end line loop +16758 (clean-up-blocks *(ebp+0xc) *Curr-block-depth *(ebp+0x10)) +16759 # decrement *Curr-block-depth +16760 ff 1/subop/decrement *Curr-block-depth +16761 # pop(vars) +16762 (pop *(ebp+0xc)) # => eax +16763 (pop *(ebp+0xc)) # => eax +16764 (pop *(ebp+0xc)) # => eax +16765 $parse-mu-block:end: +16766 # . reclaim locals +16767 81 0/subop/add %esp 0x214/imm32 +16768 # . restore registers +16769 5f/pop-to-edi +16770 5b/pop-to-ebx +16771 5a/pop-to-edx +16772 59/pop-to-ecx +16773 58/pop-to-eax +16774 # . epilogue +16775 89/<- %esp 5/r32/ebp +16776 5d/pop-to-ebp +16777 c3/return +16778 +16779 $parse-mu-block:abort: +16780 # error("'{' or '}' should be on its own line, but got '") +16781 (write-buffered *(ebp+0x18) "'{' or '}' should be on its own line, but got '") +16782 (rewind-stream %ecx) +16783 (write-stream-data *(ebp+0x18) %ecx) +16784 (write-buffered *(ebp+0x18) "'\n") +16785 (flush *(ebp+0x18)) +16786 (stop *(ebp+0x1c) 1) +16787 # never gets here +16788 +16789 new-block-name: # fn: (addr function), out: (addr handle var) +16790 # . prologue +16791 55/push-ebp +16792 89/<- %ebp 4/r32/esp +16793 # . save registers +16794 50/push-eax +16795 51/push-ecx +16796 52/push-edx +16797 # var n/ecx: int = len(fn->name) + 10 for an int + 2 for '$:' +16798 8b/-> *(ebp+8) 0/r32/eax +16799 (lookup *eax *(eax+4)) # Function-name Function-name => eax +16800 8b/-> *eax 0/r32/eax # String-size +16801 05/add-to-eax 0xd/imm32 # 10 + 2 for '$:' +16802 89/<- %ecx 0/r32/eax +16803 # var name/edx: (stream byte n) +16804 29/subtract-from %esp 1/r32/ecx +16805 ff 6/subop/push %ecx +16806 68/push 0/imm32/read +16807 68/push 0/imm32/write +16808 89/<- %edx 4/r32/esp +16809 (clear-stream %edx) +16810 # eax = fn->name +16811 8b/-> *(ebp+8) 0/r32/eax +16812 (lookup *eax *(eax+4)) # Function-name Function-name => eax +16813 # construct result using Next-block-index (and increment it) +16814 (write %edx "$") +16815 (write %edx %eax) +16816 (write %edx ":") +16817 (write-int32-hex %edx *Next-block-index) +16818 ff 0/subop/increment *Next-block-index +16819 # var s/eax: slice = {name->data, name->data + name->write} (clobbering edx) +16820 # . eax = name->write +16821 8b/-> *edx 0/r32/eax +16822 # . edx = name->data +16823 8d/copy-address *(edx+0xc) 2/r32/edx +16824 # . eax = name->write + name->data +16825 01/add-to %eax 2/r32/edx +16826 # . push {edx, eax} +16827 ff 6/subop/push %eax +16828 ff 6/subop/push %edx +16829 89/<- %eax 4/r32/esp +16830 # out = new literal(s) +16831 (new-literal Heap %eax *(ebp+0xc)) +16832 #? 8b/-> *(ebp+0xc) 0/r32/eax +16833 #? (write-buffered Stderr "type allocid in caller after new-literal: ") +16834 #? (write-int32-hex-buffered Stderr *(eax+8)) +16835 #? (write-buffered Stderr " for var ") +16836 #? (write-int32-hex-buffered Stderr %eax) +16837 #? (write-buffered Stderr Newline) +16838 #? (flush Stderr) +16839 $new-block-name:end: +16840 # . reclaim locals +16841 81 0/subop/add %ecx 0xc/imm32 # name.{read/write/len} +16842 81 0/subop/add %ecx 8/imm32 # slice +16843 01/add-to %esp 1/r32/ecx +16844 # . restore registers +16845 5a/pop-to-edx +16846 59/pop-to-ecx +16847 58/pop-to-eax +16848 # . epilogue +16849 89/<- %esp 5/r32/ebp +16850 5d/pop-to-ebp +16851 c3/return +16852 +16853 check-no-tokens-left: # line: (addr stream byte) +16854 # . prologue +16855 55/push-ebp +16856 89/<- %ebp 4/r32/esp +16857 # . save registers +16858 50/push-eax +16859 51/push-ecx +16860 # var s/ecx: slice +16861 68/push 0/imm32/end +16862 68/push 0/imm32/start +16863 89/<- %ecx 4/r32/esp +16864 # +16865 (next-mu-token *(ebp+8) %ecx) +16866 # if slice-empty?(s) return +16867 (slice-empty? %ecx) +16868 3d/compare-eax-and 0/imm32/false +16869 75/jump-if-!= $check-no-tokens-left:end/disp8 +16870 # if (slice-starts-with?(s, '#') return +16871 # . eax = *s->start +16872 8b/-> *edx 0/r32/eax +16873 8a/copy-byte *eax 0/r32/AL +16874 81 4/subop/and %eax 0xff/imm32 +16875 # . if (eax == '#') continue +16876 3d/compare-eax-and 0x23/imm32/hash +16877 74/jump-if-= $check-no-tokens-left:end/disp8 +16878 # abort +16879 (write-buffered Stderr "'{' or '}' should be on its own line, but got '") +16880 (rewind-stream %ecx) +16881 (write-stream 2 %ecx) +16882 (write-buffered Stderr "'\n") +16883 (flush Stderr) +16884 # . syscall(exit, 1) +16885 bb/copy-to-ebx 1/imm32 +16886 e8/call syscall_exit/disp32 +16887 # never gets here +16888 $check-no-tokens-left:end: +16889 # . reclaim locals +16890 81 0/subop/add %esp 8/imm32 +16891 # . restore registers +16892 59/pop-to-ecx +16893 58/pop-to-eax +16894 # . epilogue +16895 89/<- %esp 5/r32/ebp +16896 5d/pop-to-ebp +16897 c3/return +16898 +16899 parse-mu-named-block: # name: (addr slice), in: (addr buffered-file), vars: (addr stack live-var), fn: (addr function), out: (addr handle stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +16900 # pseudocode: +16901 # var v: (handle var) +16902 # new-literal(name, v) +16903 # push(vars, {v, false}) +16904 # parse-mu-block(in, vars, fn, out) +16905 # pop(vars) +16906 # out->tag = block +16907 # out->var = v +16908 # +16909 # . prologue +16910 55/push-ebp +16911 89/<- %ebp 4/r32/esp +16912 # . save registers +16913 50/push-eax +16914 51/push-ecx +16915 57/push-edi +16916 # var v/ecx: (handle var) +16917 68/push 0/imm32 +16918 68/push 0/imm32 +16919 89/<- %ecx 4/r32/esp +16920 # +16921 (new-literal Heap *(ebp+8) %ecx) +16922 # push(vars, v) +16923 (push *(ebp+0x10) *ecx) +16924 (push *(ebp+0x10) *(ecx+4)) +16925 (push *(ebp+0x10) 0) # false +16926 # +16927 (parse-mu-block *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c) *(ebp+0x20)) +16928 # pop v off vars +16929 (pop *(ebp+0x10)) # => eax +16930 (pop *(ebp+0x10)) # => eax +16931 (pop *(ebp+0x10)) # => eax +16932 # var out-addr/edi: (addr stmt) = lookup(*out) +16933 8b/-> *(ebp+0x18) 7/r32/edi +16934 (lookup *edi *(edi+4)) # => eax +16935 89/<- %edi 0/r32/eax +16936 # out-addr->tag = named-block +16937 c7 0/subop/copy *edi 0/imm32/block # Stmt-tag +16938 # out-addr->var = v +16939 8b/-> *ecx 0/r32/eax +16940 89/<- *(edi+0xc) 0/r32/eax # Block-var +16941 8b/-> *(ecx+4) 0/r32/eax +16942 89/<- *(edi+0x10) 0/r32/eax # Block-var +16943 $parse-mu-named-block:end: +16944 # . reclaim locals +16945 81 0/subop/add %esp 8/imm32 +16946 # . restore registers +16947 5f/pop-to-edi +16948 59/pop-to-ecx +16949 58/pop-to-eax +16950 # . epilogue +16951 89/<- %esp 5/r32/ebp +16952 5d/pop-to-ebp +16953 c3/return +16954 +16955 parse-mu-var-def: # line: (addr stream byte), vars: (addr stack live-var), out: (addr handle stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +16956 # . prologue +16957 55/push-ebp +16958 89/<- %ebp 4/r32/esp +16959 # . save registers +16960 50/push-eax +16961 51/push-ecx +16962 52/push-edx +16963 56/push-esi +16964 57/push-edi +16965 # edi = out +16966 8b/-> *(ebp+0x10) 7/r32/edi +16967 # var word-slice/ecx: slice +16968 68/push 0/imm32/end +16969 68/push 0/imm32/start +16970 89/<- %ecx 4/r32/esp +16971 # var v/edx: (handle var) +16972 68/push 0/imm32 +16973 68/push 0/imm32 +16974 89/<- %edx 4/r32/esp +16975 # v = parse-var-with-type(next-mu-token(line)) +16976 (next-mu-token *(ebp+8) %ecx) +16977 { +16978 # just for tests, support null fn +16979 8b/-> *(ebp+0x14) 0/r32/eax +16980 3d/compare-eax-and 0/imm32 +16981 74/jump-if-= break/disp8 +16982 (lookup *eax *(eax+4)) # Var-name Var-name => eax +16983 } +16984 (parse-var-with-type %ecx *(ebp+8) %edx %eax *(ebp+0x18) *(ebp+0x1c)) +16985 # var v-addr/esi: (addr var) +16986 (lookup *edx *(edx+4)) # => eax +16987 89/<- %esi 0/r32/eax +16988 # v->block-depth = *Curr-block-depth +16989 8b/-> *Curr-block-depth 0/r32/eax +16990 89/<- *(esi+0x10) 0/r32/eax # Var-block-depth +16991 # either v has no register and there's no more to this line +16992 81 7/subop/compare *(esi+0x18) 0/imm32 +16993 { +16994 75/jump-if-!= break/disp8 +16995 # if v-addr->type == byte, abort +16996 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax +16997 (is-simple-mu-type? %eax 8) # byte => eax +16998 3d/compare-eax-and 0/imm32/false +16999 0f 85/jump-if-!= $parse-mu-var-def:error-byte-on-stack/disp32 +17000 # ensure that there's nothing else on this line +17001 (next-mu-token *(ebp+8) %ecx) +17002 (slice-empty? %ecx) # => eax +17003 3d/compare-eax-and 0/imm32/false +17004 0f 84/jump-if-= $parse-mu-var-def:error2/disp32 +17005 # +17006 (new-var-def Heap *edx *(edx+4) %edi) +17007 e9/jump $parse-mu-var-def:update-vars/disp32 +17008 } +17009 # or v has a register and there's more to this line +17010 { +17011 0f 84/jump-if-= break/disp32 +17012 # if v-addr->type == byte, check for unsupported registers +17013 { +17014 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax +17015 (is-simple-mu-type? %eax 8) # byte => eax +17016 3d/compare-eax-and 0/imm32/false +17017 74/jump-if-= break/disp8 +17018 (lookup *(esi+0x18) *(esi+0x1c)) # => eax +17019 (string-equal? %eax "esi") # => eax +17020 3d/compare-eax-and 0/imm32/false +17021 0f 85/jump-if-!= $parse-mu-var-def:error-byte-registers/disp32 +17022 (lookup *(esi+0x18) *(esi+0x1c)) # => eax +17023 (string-equal? %eax "edi") # => eax +17024 3d/compare-eax-and 0/imm32/false +17025 0f 85/jump-if-!= $parse-mu-var-def:error-byte-registers/disp32 +17026 } +17027 # TODO: vars of type 'byte' should only be initialized by clearing to 0 +17028 # ensure that the next word is '<-' +17029 (next-mu-token *(ebp+8) %ecx) +17030 (slice-equal? %ecx "<-") # => eax +17031 3d/compare-eax-and 0/imm32/false +17032 0f 84/jump-if-= $parse-mu-var-def:error1/disp32 +17033 # +17034 (new-reg-var-def Heap *edx *(edx+4) %edi) +17035 (lookup *edi *(edi+4)) # => eax +17036 (add-operation-and-inputs-to-stmt %eax *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +17037 } +17038 $parse-mu-var-def:update-vars: +17039 # push 'v' at end of function +17040 (push *(ebp+0xc) *edx) +17041 (push *(ebp+0xc) *(edx+4)) +17042 (push *(ebp+0xc) 0) # Live-var-register-spilled is unused during parsing +17043 $parse-mu-var-def:end: +17044 # . reclaim locals +17045 81 0/subop/add %esp 0x10/imm32 +17046 # . restore registers +17047 5f/pop-to-edi +17048 5e/pop-to-esi +17049 5a/pop-to-edx +17050 59/pop-to-ecx +17051 58/pop-to-eax +17052 # . epilogue +17053 89/<- %esp 5/r32/ebp +17054 5d/pop-to-ebp +17055 c3/return +17056 +17057 $parse-mu-var-def:error1: +17058 (rewind-stream *(ebp+8)) +17059 # error("register variable requires a valid instruction to initialize but got '" line "'\n") +17060 (write-buffered *(ebp+0x18) "register variable requires a valid instruction to initialize but got '") +17061 (flush *(ebp+0x18)) +17062 (write-stream-data *(ebp+0x18) *(ebp+8)) +17063 (write-buffered *(ebp+0x18) "'\n") +17064 (flush *(ebp+0x18)) +17065 (stop *(ebp+0x1c) 1) +17066 # never gets here +17067 +17068 $parse-mu-var-def:error2: +17069 # error("fn " fn ": var " var ": variables on the stack can't take an initializer\n") +17070 (write-buffered *(ebp+0x18) "fn ") +17071 8b/-> *(ebp+0x14) 0/r32/eax +17072 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17073 (write-buffered *(ebp+0x18) %eax) +17074 (write-buffered *(ebp+0x18) ": var ") +17075 # var v-addr/eax: (addr var) = lookup(v) +17076 (lookup *edx *(edx+4)) # => eax +17077 (lookup *eax *(eax+4)) # Var-name Var-name => eax +17078 (write-buffered *(ebp+0x18) %eax) +17079 (write-buffered *(ebp+0x18) ": variables on the stack can't take an initializer\n") +17080 (flush *(ebp+0x18)) +17081 (stop *(ebp+0x1c) 1) +17082 # never gets here +17083 +17084 $parse-mu-var-def:error-byte-on-stack: +17085 # error("fn " fn ": var '" var "' of type 'byte' cannot be on the stack\n") +17086 (write-buffered *(ebp+0x18) "fn ") +17087 8b/-> *(ebp+0x14) 0/r32/eax +17088 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17089 (write-buffered *(ebp+0x18) %eax) +17090 (write-buffered *(ebp+0x18) ": var '") +17091 # var v-addr/eax: (addr var) = lookup(v) +17092 (lookup *edx *(edx+4)) # => eax +17093 (lookup *eax *(eax+4)) # Var-name Var-name => eax +17094 (write-buffered *(ebp+0x18) %eax) +17095 (write-buffered *(ebp+0x18) "' of type 'byte' cannot be on the stack\n") +17096 (flush *(ebp+0x18)) +17097 (stop *(ebp+0x1c) 1) +17098 # never gets here +17099 +17100 $parse-mu-var-def:error-byte-registers: +17101 # error("fn " fn ": var '" var "' of type 'byte' cannot be in esi or edi\n") +17102 (write-buffered *(ebp+0x18) "fn ") +17103 8b/-> *(ebp+0x14) 0/r32/eax +17104 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17105 (write-buffered *(ebp+0x18) %eax) +17106 (write-buffered *(ebp+0x18) ": var '") +17107 # var v-addr/eax: (addr var) = lookup(v) +17108 (lookup *edx *(edx+4)) # => eax +17109 (lookup *eax *(eax+4)) # Var-name Var-name => eax +17110 (write-buffered *(ebp+0x18) %eax) +17111 (write-buffered *(ebp+0x18) "' of type 'byte' cannot be in esi or edi\n") +17112 (flush *(ebp+0x18)) +17113 (stop *(ebp+0x1c) 1) +17114 # never gets here +17115 +17116 test-parse-mu-var-def: +17117 # 'var n: int' +17118 # . prologue +17119 55/push-ebp +17120 89/<- %ebp 4/r32/esp +17121 # setup +17122 8b/-> *Primitive-type-ids 0/r32/eax +17123 89/<- *Type-id 0/r32/eax # stream-write +17124 (clear-stream _test-input-stream) +17125 (write _test-input-stream "n: int\n") # caller has consumed the 'var' +17126 c7 0/subop/copy *Curr-block-depth 1/imm32 +17127 # var out/esi: (handle stmt) +17128 68/push 0/imm32 +17129 68/push 0/imm32 +17130 89/<- %esi 4/r32/esp +17131 # var vars/ecx: (stack (addr var) 16) +17132 81 5/subop/subtract %esp 0xc0/imm32 +17133 68/push 0xc0/imm32/size +17134 68/push 0/imm32/top +17135 89/<- %ecx 4/r32/esp +17136 (clear-stack %ecx) +17137 # convert +17138 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0) +17139 # var out-addr/esi: (addr stmt) +17140 (lookup *esi *(esi+4)) # => eax +17141 89/<- %esi 0/r32/eax +17142 # +17143 (check-ints-equal *esi 2 "F - test-parse-mu-var-def/tag") # Stmt-tag is var-def +17144 # var v/ecx: (addr var) = lookup(out->var) +17145 (lookup *(esi+4) *(esi+8)) # Vardef-var Vardef-var => eax +17146 89/<- %ecx 0/r32/eax +17147 # v->name +17148 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +17149 (check-strings-equal %eax "n" "F - test-parse-mu-var-def/var-name") +17150 # v->register +17151 (check-ints-equal *(ecx+0x18) 0 "F - test-parse-mu-var-def/var-register") # Var-register +17152 # v->block-depth +17153 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-var-def/output-block-depth") # Var-block-depth +17154 # v->type == int +17155 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +17156 (check-ints-equal *eax 1 "F - test-parse-mu-var-def/var-type:0") # Type-tree-is-atom +17157 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-var-def/var-type:1") # Type-tree-value +17158 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-var-def/var-type:2") # Type-tree-right +17159 # . epilogue +17160 89/<- %esp 5/r32/ebp +17161 5d/pop-to-ebp +17162 c3/return +17163 +17164 test-parse-mu-reg-var-def: +17165 # 'var n/eax: int <- copy 0' +17166 # . prologue +17167 55/push-ebp +17168 89/<- %ebp 4/r32/esp +17169 # setup +17170 8b/-> *Primitive-type-ids 0/r32/eax +17171 89/<- *Type-id 0/r32/eax # stream-write +17172 (clear-stream _test-input-stream) +17173 (write _test-input-stream "n/eax: int <- copy 0\n") # caller has consumed the 'var' +17174 c7 0/subop/copy *Curr-block-depth 1/imm32 +17175 # var out/esi: (handle stmt) +17176 68/push 0/imm32 +17177 68/push 0/imm32 +17178 89/<- %esi 4/r32/esp +17179 # var vars/ecx: (stack (addr var) 16) +17180 81 5/subop/subtract %esp 0xc0/imm32 +17181 68/push 0xc0/imm32/size +17182 68/push 0/imm32/top +17183 89/<- %ecx 4/r32/esp +17184 (clear-stack %ecx) +17185 # convert +17186 (parse-mu-var-def _test-input-stream %ecx %esi 0 Stderr 0) +17187 # var out-addr/esi: (addr stmt) +17188 (lookup *esi *(esi+4)) # => eax +17189 89/<- %esi 0/r32/eax +17190 # +17191 (check-ints-equal *esi 3 "F - test-parse-mu-reg-var-def/tag") # Stmt-tag is reg-var-def +17192 # var v/ecx: (addr var) = lookup(out->outputs->value) +17193 # . eax: (addr stmt-var) = lookup(out->outputs) +17194 (lookup *(esi+0x14) *(esi+0x18)) # Regvardef-outputs Regvardef-outputs => eax +17195 # . +17196 (check-ints-equal *(eax+8) 0 "F - test-parse-mu-reg-var-def/single-output") # Stmt-var-next +17197 # . eax: (addr var) = lookup(eax->value) +17198 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +17199 # . ecx = eax +17200 89/<- %ecx 0/r32/eax +17201 # v->name +17202 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +17203 (check-strings-equal %eax "n" "F - test-parse-mu-reg-var-def/output-name") # Var-name +17204 # v->register +17205 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax +17206 (check-strings-equal %eax "eax" "F - test-parse-mu-reg-var-def/output-register") +17207 # v->block-depth +17208 (check-ints-equal *(ecx+0x10) 1 "F - test-parse-mu-reg-var-def/output-block-depth") # Var-block-depth +17209 # v->type == int +17210 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +17211 (check-ints-equal *eax 1 "F - test-parse-mu-reg-var-def/output-type:0") # Type-tree-is-atom +17212 (check-ints-equal *(eax+4) 1 "F - test-parse-mu-reg-var-def/output-type:1") # Type-tree-value +17213 (check-ints-equal *(eax+0xc) 0 "F - test-parse-mu-reg-var-def/output-type:2") # Type-tree-right +17214 # . epilogue +17215 89/<- %esp 5/r32/ebp +17216 5d/pop-to-ebp +17217 c3/return +17218 +17219 parse-mu-stmt: # line: (addr stream byte), vars: (addr stack live-var), fn: (addr function), out: (addr handle stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +17220 # pseudocode: +17221 # var name: slice +17222 # allocate(Heap, Stmt-size, out) +17223 # var out-addr: (addr stmt) = lookup(*out) +17224 # out-addr->tag = stmt +17225 # if stmt-has-outputs?(line) +17226 # while true +17227 # name = next-mu-token(line) +17228 # if (name == '<-') break +17229 # assert(is-identifier?(name)) +17230 # var v: (handle var) = lookup-var(name, vars) +17231 # out-addr->outputs = append(v, out-addr->outputs) +17232 # add-operation-and-inputs-to-stmt(out-addr, line, vars) +17233 # +17234 # . prologue +17235 55/push-ebp +17236 89/<- %ebp 4/r32/esp +17237 # . save registers +17238 50/push-eax +17239 51/push-ecx +17240 52/push-edx +17241 53/push-ebx +17242 57/push-edi +17243 # var name/ecx: slice +17244 68/push 0/imm32/end +17245 68/push 0/imm32/start +17246 89/<- %ecx 4/r32/esp +17247 # var is-deref?/edx: boolean = false +17248 ba/copy-to-edx 0/imm32/false +17249 # var v: (handle var) +17250 68/push 0/imm32 +17251 68/push 0/imm32 +17252 89/<- %ebx 4/r32/esp +17253 # +17254 (allocate Heap *Stmt-size *(ebp+0x14)) +17255 # var out-addr/edi: (addr stmt) = lookup(*out) +17256 8b/-> *(ebp+0x14) 7/r32/edi +17257 (lookup *edi *(edi+4)) # => eax +17258 89/<- %edi 0/r32/eax +17259 # out-addr->tag = 1/stmt +17260 c7 0/subop/copy *edi 1/imm32/stmt1 # Stmt-tag +17261 { +17262 (stmt-has-outputs? *(ebp+8)) +17263 3d/compare-eax-and 0/imm32/false +17264 0f 84/jump-if-= break/disp32 +17265 { +17266 $parse-mu-stmt:read-outputs: +17267 # name = next-mu-token(line) +17268 (next-mu-token *(ebp+8) %ecx) +17269 # if slice-empty?(word-slice) break +17270 (slice-empty? %ecx) # => eax +17271 3d/compare-eax-and 0/imm32/false +17272 0f 85/jump-if-!= break/disp32 +17273 # if (name == "<-") break +17274 (slice-equal? %ecx "<-") # => eax +17275 3d/compare-eax-and 0/imm32/false +17276 0f 85/jump-if-!= break/disp32 +17277 # if slice-starts-with?(name, "*") abort +17278 8b/-> *ecx 0/r32/eax # Slice-start +17279 8a/copy-byte *eax 0/r32/AL +17280 81 4/subop/and %eax 0xff/imm32 +17281 3d/compare-eax-and 0x2a/imm32/asterisk +17282 0f 84/jump-if-= $parse-mu-stmt:error-output-dereferenced/disp32 +17283 # assert(is-identifier?(name)) +17284 (is-identifier? %ecx) # => eax +17285 3d/compare-eax-and 0/imm32/false +17286 0f 84/jump-if-= $parse-mu-stmt:abort/disp32 +17287 # +17288 (lookup-var %ecx *(ebp+0xc) %ebx *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) +17289 8d/copy-address *(edi+0x14) 0/r32/eax # Stmt1-outputs +17290 (append-stmt-var Heap *ebx *(ebx+4) *(edi+0x14) *(edi+0x18) 0 %eax) # Stmt1-outputs +17291 # +17292 e9/jump loop/disp32 +17293 } +17294 } +17295 (add-operation-and-inputs-to-stmt %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x18) *(ebp+0x1c)) +17296 $parse-mu-stmt:end: +17297 # . reclaim locals +17298 81 0/subop/add %esp 0x10/imm32 +17299 # . restore registers +17300 5f/pop-to-edi +17301 5b/pop-to-ebx +17302 5a/pop-to-edx +17303 59/pop-to-ecx +17304 58/pop-to-eax +17305 # . epilogue +17306 89/<- %esp 5/r32/ebp +17307 5d/pop-to-ebp +17308 c3/return +17309 +17310 $parse-mu-stmt:abort: +17311 # error("invalid identifier '" name "'\n") +17312 (write-buffered *(ebp+0x18) "fn ") +17313 8b/-> *(ebp+0x10) 0/r32/eax +17314 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17315 (write-buffered *(ebp+0x18) %eax) +17316 (write-buffered *(ebp+0x18) ": invalid identifier '") +17317 (write-slice-buffered *(ebp+0x18) %ecx) +17318 (write-buffered *(ebp+0x18) "'\n") +17319 (flush *(ebp+0x18)) +17320 (stop *(ebp+0x1c) 1) +17321 # never gets here +17322 +17323 $parse-mu-stmt:error-output-dereferenced: +17324 # error("invalid identifier '" name "'\n") +17325 (write-buffered *(ebp+0x18) "fn ") +17326 8b/-> *(ebp+0x10) 0/r32/eax +17327 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17328 (write-buffered *(ebp+0x18) %eax) +17329 (write-buffered *(ebp+0x18) ": output '") +17330 (write-slice-buffered *(ebp+0x18) %ecx) +17331 (write-buffered *(ebp+0x18) "' should write to a register, and therefore cannot be dereferenced\n") +17332 (flush *(ebp+0x18)) +17333 (stop *(ebp+0x1c) 1) +17334 # never gets here +17335 +17336 add-operation-and-inputs-to-stmt: # stmt: (addr stmt), line: (addr stream byte), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +17337 # pseudocode: +17338 # stmt->name = slice-to-string(next-mu-token(line)) +17339 # while true +17340 # name = next-mu-token(line) +17341 # v = lookup-var-or-literal(name) +17342 # stmt->inouts = append(v, stmt->inouts) +17343 # +17344 # . prologue +17345 55/push-ebp +17346 89/<- %ebp 4/r32/esp +17347 # . save registers +17348 50/push-eax +17349 51/push-ecx +17350 52/push-edx +17351 53/push-ebx +17352 56/push-esi +17353 57/push-edi +17354 # edi = stmt +17355 8b/-> *(ebp+8) 7/r32/edi +17356 # var name/ecx: slice +17357 68/push 0/imm32/end +17358 68/push 0/imm32/start +17359 89/<- %ecx 4/r32/esp +17360 # var is-deref?/edx: boolean = false +17361 ba/copy-to-edx 0/imm32/false +17362 # var v/esi: (handle var) +17363 68/push 0/imm32 +17364 68/push 0/imm32 +17365 89/<- %esi 4/r32/esp +17366 $add-operation-and-inputs-to-stmt:read-operation: +17367 (next-mu-token *(ebp+0xc) %ecx) +17368 8d/copy-address *(edi+4) 0/r32/eax # Stmt1-operation or Regvardef-operationStmt1-operation or Regvardef-operation +17369 (slice-to-string Heap %ecx %eax) +17370 # var is-get?/ebx: boolean = (name == "get") +17371 (slice-equal? %ecx "get") # => eax +17372 89/<- %ebx 0/r32/eax +17373 { +17374 $add-operation-and-inputs-to-stmt:read-inouts: +17375 # name = next-mu-token(line) +17376 (next-mu-token *(ebp+0xc) %ecx) +17377 # if slice-empty?(word-slice) break +17378 (slice-empty? %ecx) # => eax +17379 3d/compare-eax-and 0/imm32/false +17380 0f 85/jump-if-!= break/disp32 +17381 # if (name == "<-") abort +17382 (slice-equal? %ecx "<-") +17383 3d/compare-eax-and 0/imm32/false +17384 0f 85/jump-if-!= $add-operation-and-inputs-to-stmt:abort/disp32 +17385 # if (is-get? && second operand) lookup or create offset +17386 { +17387 81 7/subop/compare %ebx 0/imm32/false +17388 74/jump-if-= break/disp8 +17389 (lookup *(edi+0xc) *(edi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +17390 3d/compare-eax-and 0/imm32 +17391 74/jump-if-= break/disp8 +17392 (lookup-or-create-constant %eax %ecx %esi) +17393 #? (lookup *esi *(esi+4)) +17394 #? (write-buffered Stderr "creating new output var ") +17395 #? (write-int32-hex-buffered Stderr %eax) +17396 #? (write-buffered Stderr " for field called ") +17397 #? (write-slice-buffered Stderr %ecx) +17398 #? (write-buffered Stderr "; var name ") +17399 #? (lookup *eax *(eax+4)) # Var-name +17400 #? (write-buffered Stderr %eax) +17401 #? (write-buffered Stderr Newline) +17402 #? (flush Stderr) +17403 e9/jump $add-operation-and-inputs-to-stmt:save-var/disp32 +17404 } +17405 # is-deref? = false +17406 ba/copy-to-edx 0/imm32/false +17407 # if (slice-starts-with?(name, '*')) ++name->start and set is-deref? +17408 8b/-> *ecx 0/r32/eax # Slice-start +17409 8a/copy-byte *eax 0/r32/AL +17410 81 4/subop/and %eax 0xff/imm32 +17411 3d/compare-eax-and 0x2a/imm32/asterisk +17412 { +17413 75/jump-if-!= break/disp8 +17414 $add-operation-and-inputs-to-stmt:inout-is-deref: +17415 ff 0/subop/increment *ecx +17416 ba/copy-to-edx 1/imm32/true +17417 } +17418 (lookup-var-or-literal %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +17419 # if (is-deref?) some additional checks +17420 81 7/subop/compare %edx 0/imm32/false +17421 { +17422 74/jump-if-= break/disp8 +17423 # if var is not in register, abort +17424 (lookup *esi *(esi+4)) # => eax +17425 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +17426 0f 84/jump-if-= $add-operation-and-inputs-to-stmt:error-deref-on-stack/disp32 +17427 # if var is not an address, abort +17428 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +17429 (is-mu-addr-type? %eax) # => eax +17430 3d/compare-eax-and 0/imm32/false +17431 0f 84/jump-if-= $add-operation-and-inputs-to-stmt:error-deref-non-addr/disp32 +17432 } +17433 $add-operation-and-inputs-to-stmt:save-var: +17434 8d/copy-address *(edi+0xc) 0/r32/eax +17435 (append-stmt-var Heap *esi *(esi+4) *(edi+0xc) *(edi+0x10) %edx %eax) # Stmt1-inouts or Regvardef-inouts +17436 # +17437 e9/jump loop/disp32 +17438 } +17439 $add-operation-and-inputs-to-stmt:end: +17440 # . reclaim locals +17441 81 0/subop/add %esp 0x10/imm32 +17442 # . restore registers +17443 5f/pop-to-edi +17444 5e/pop-to-esi +17445 5b/pop-to-ebx +17446 5a/pop-to-edx +17447 59/pop-to-ecx +17448 58/pop-to-eax +17449 # . epilogue +17450 89/<- %esp 5/r32/ebp +17451 5d/pop-to-ebp +17452 c3/return +17453 +17454 $add-operation-and-inputs-to-stmt:abort: +17455 # error("fn ___: invalid identifier in '" line "'\n") +17456 (write-buffered *(ebp+0x18) "fn ") +17457 8b/-> *(ebp+0x14) 0/r32/eax +17458 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17459 (write-buffered *(ebp+0x18) %eax) +17460 (rewind-stream *(ebp+0xc)) +17461 (write-buffered *(ebp+0x18) ": invalid identifier in '") +17462 (write-stream-data *(ebp+0x18) *(ebp+0xc)) +17463 (write-buffered *(ebp+0x18) "'\n") +17464 (flush *(ebp+0x18)) +17465 (stop *(ebp+0x1c) 1) +17466 # never gets here +17467 +17468 $add-operation-and-inputs-to-stmt:error-deref-on-stack: +17469 # error("fn ___: cannot dereference var ___ on stack\n") +17470 (write-buffered *(ebp+0x18) "fn ") +17471 8b/-> *(ebp+0x14) 0/r32/eax +17472 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17473 (write-buffered *(ebp+0x18) %eax) +17474 (rewind-stream *(ebp+0xc)) +17475 (write-buffered *(ebp+0x18) ": cannot dereference var '") +17476 (lookup *esi *(esi+4)) # => eax +17477 (lookup *eax *(eax+4)) # Var-name Var-name => eax +17478 (write-buffered *(ebp+0x18) %eax) +17479 (write-buffered *(ebp+0x18) "' on stack\n") +17480 (flush *(ebp+0x18)) +17481 (stop *(ebp+0x1c) 1) +17482 # never gets here +17483 +17484 $add-operation-and-inputs-to-stmt:error-deref-non-addr: +17485 # error("fn ___: cannot dereference non-addr var ___\n") +17486 (write-buffered *(ebp+0x18) "fn ") +17487 8b/-> *(ebp+0x14) 0/r32/eax +17488 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17489 (write-buffered *(ebp+0x18) %eax) +17490 (rewind-stream *(ebp+0xc)) +17491 (write-buffered *(ebp+0x18) ": cannot dereference non-addr var '") +17492 (lookup *esi *(esi+4)) # => eax +17493 (lookup *eax *(eax+4)) # Var-name Var-name => eax +17494 (write-buffered *(ebp+0x18) %eax) +17495 (write-buffered *(ebp+0x18) "'\n") +17496 (flush *(ebp+0x18)) +17497 (stop *(ebp+0x1c) 1) +17498 # never gets here +17499 +17500 stmt-has-outputs?: # line: (addr stream byte) -> result/eax: boolean +17501 # . prologue +17502 55/push-ebp +17503 89/<- %ebp 4/r32/esp +17504 # . save registers +17505 51/push-ecx +17506 # var word-slice/ecx: slice +17507 68/push 0/imm32/end +17508 68/push 0/imm32/start +17509 89/<- %ecx 4/r32/esp +17510 # result = false +17511 b8/copy-to-eax 0/imm32/false +17512 (rewind-stream *(ebp+8)) +17513 { +17514 (next-mu-token *(ebp+8) %ecx) +17515 # if slice-empty?(word-slice) break +17516 (slice-empty? %ecx) +17517 3d/compare-eax-and 0/imm32/false +17518 b8/copy-to-eax 0/imm32/false/result # restore result (if we're here it's still false) +17519 0f 85/jump-if-!= break/disp32 +17520 # if slice-starts-with?(word-slice, '#') break +17521 # . eax = *word-slice->start +17522 8b/-> *ecx 0/r32/eax +17523 8a/copy-byte *eax 0/r32/AL +17524 81 4/subop/and %eax 0xff/imm32 +17525 # . if (eax == '#') break +17526 3d/compare-eax-and 0x23/imm32/hash +17527 b8/copy-to-eax 0/imm32/false/result # restore result (if we're here it's still false) +17528 0f 84/jump-if-= break/disp32 +17529 # if slice-equal?(word-slice, '<-') return true +17530 (slice-equal? %ecx "<-") +17531 3d/compare-eax-and 0/imm32/false +17532 74/jump-if-= loop/disp8 +17533 b8/copy-to-eax 1/imm32/true +17534 } +17535 $stmt-has-outputs:end: +17536 (rewind-stream *(ebp+8)) +17537 # . reclaim locals +17538 81 0/subop/add %esp 8/imm32 +17539 # . restore registers +17540 59/pop-to-ecx +17541 # . epilogue +17542 89/<- %esp 5/r32/ebp +17543 5d/pop-to-ebp +17544 c3/return +17545 +17546 # if 'name' starts with a digit, create a new literal var for it +17547 # otherwise return first 'name' from the top (back) of 'vars' and abort if not found +17548 lookup-var-or-literal: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +17549 # . prologue +17550 55/push-ebp +17551 89/<- %ebp 4/r32/esp +17552 # . save registers +17553 50/push-eax +17554 51/push-ecx +17555 56/push-esi +17556 # esi = name +17557 8b/-> *(ebp+8) 6/r32/esi +17558 # if slice-empty?(name) abort +17559 (slice-empty? %esi) # => eax +17560 3d/compare-eax-and 0/imm32/false +17561 0f 85/jump-if-!= $lookup-var-or-literal:abort/disp32 +17562 # var c/ecx: byte = *name->start +17563 8b/-> *esi 1/r32/ecx +17564 8a/copy-byte *ecx 1/r32/CL +17565 81 4/subop/and %ecx 0xff/imm32 +17566 # if (is-decimal-digit?(c) || c == '-') return new var(name) +17567 { +17568 81 7/subop/compare %ecx 0x2d/imm32/dash +17569 74/jump-if-= $lookup-var-or-literal:literal/disp8 +17570 (is-decimal-digit? %ecx) # => eax +17571 3d/compare-eax-and 0/imm32/false +17572 74/jump-if-= break/disp8 +17573 $lookup-var-or-literal:literal: +17574 (new-literal-integer Heap %esi *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +17575 eb/jump $lookup-var-or-literal:end/disp8 +17576 } +17577 # else if (c == '"') return new var(name) +17578 { +17579 81 7/subop/compare %ecx 0x22/imm32/dquote +17580 75/jump-if-!= break/disp8 +17581 $lookup-var-or-literal:literal-string: +17582 (new-literal-string Heap %esi *(ebp+0x10)) +17583 eb/jump $lookup-var-or-literal:end/disp8 +17584 } +17585 # otherwise return lookup-var(name, vars) +17586 { +17587 $lookup-var-or-literal:var: +17588 (lookup-var %esi *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +17589 } +17590 $lookup-var-or-literal:end: +17591 # . restore registers +17592 5e/pop-to-esi +17593 59/pop-to-ecx 17594 58/pop-to-eax 17595 # . epilogue 17596 89/<- %esp 5/r32/ebp 17597 5d/pop-to-ebp 17598 c3/return 17599 -17600 append-list: # ad: (addr allocation-descriptor), value: (handle _type), list: (handle list _type), out: (addr handle list _type) -17601 # . prologue -17602 55/push-ebp -17603 89/<- %ebp 4/r32/esp -17604 # . save registers -17605 50/push-eax -17606 51/push-ecx -17607 57/push-edi -17608 # edi = out -17609 8b/-> *(ebp+0x1c) 7/r32/edi -17610 # *out = new list -17611 (allocate *(ebp+8) *List-size %edi) -17612 # var out-addr/edi: (addr list _type) = lookup(*out) -17613 (lookup *edi *(edi+4)) # => eax -17614 89/<- %edi 0/r32/eax -17615 # out-addr->value = value -17616 8b/-> *(ebp+0xc) 0/r32/eax -17617 89/<- *edi 0/r32/eax # List-value -17618 8b/-> *(ebp+0x10) 0/r32/eax -17619 89/<- *(edi+4) 0/r32/eax # List-value -17620 # if (list == null) return -17621 81 7/subop/compare *(ebp+0x14) 0/imm32 -17622 74/jump-if-= $append-list:end/disp8 -17623 # otherwise append -17624 $append-list:non-empty-list: -17625 # var curr/eax: (addr list _type) = lookup(list) -17626 (lookup *(ebp+0x14) *(ebp+0x18)) # => eax -17627 # while (curr->next != null) curr = curr->next -17628 { -17629 81 7/subop/compare *(eax+8) 0/imm32 # List-next -17630 74/jump-if-= break/disp8 -17631 # curr = lookup(curr->next) -17632 (lookup *(eax+8) *(eax+0xc)) # List-next, List-next => eax -17633 # -17634 eb/jump loop/disp8 -17635 } -17636 # edi = out -17637 8b/-> *(ebp+0x1c) 7/r32/edi -17638 # curr->next = out -17639 8b/-> *edi 1/r32/ecx -17640 89/<- *(eax+8) 1/r32/ecx # List-next -17641 8b/-> *(edi+4) 1/r32/ecx -17642 89/<- *(eax+0xc) 1/r32/ecx # List-next -17643 # out = list -17644 8b/-> *(ebp+0x14) 1/r32/ecx -17645 89/<- *edi 1/r32/ecx -17646 8b/-> *(ebp+0x18) 1/r32/ecx -17647 89/<- *(edi+4) 1/r32/ecx -17648 $append-list:end: -17649 # . restore registers -17650 5f/pop-to-edi -17651 59/pop-to-ecx -17652 58/pop-to-eax -17653 # . epilogue -17654 89/<- %esp 5/r32/ebp -17655 5d/pop-to-ebp -17656 c3/return -17657 -17658 append-stmt-var: # ad: (addr allocation-descriptor), v: (handle var), vars: (handle stmt-var), is-deref?: boolean, out: (addr handle stmt-var) -17659 # . prologue -17660 55/push-ebp -17661 89/<- %ebp 4/r32/esp -17662 # . save registers -17663 50/push-eax -17664 51/push-ecx -17665 57/push-edi -17666 # edi = out -17667 8b/-> *(ebp+0x20) 7/r32/edi -17668 # out = new stmt-var -17669 (allocate *(ebp+8) *Stmt-var-size %edi) -17670 # var out-addr/ecx: (addr stmt-var) = lookup(*out) -17671 (lookup *edi *(edi+4)) # => eax -17672 89/<- %ecx 0/r32/eax -17673 # out-addr->value = v -17674 8b/-> *(ebp+0xc) 0/r32/eax -17675 89/<- *ecx 0/r32/eax # Stmt-var-value -17676 8b/-> *(ebp+0x10) 0/r32/eax -17677 89/<- *(ecx+4) 0/r32/eax # Stmt-var-value -17678 # out-addr->is-deref? = is-deref? -17679 8b/-> *(ebp+0x1c) 0/r32/eax -17680 89/<- *(ecx+0x10) 0/r32/eax # Stmt-var-is-deref -17681 # if (vars == null) return result -17682 81 7/subop/compare *(ebp+0x14) 0/imm32/null -17683 74/jump-if-= $append-stmt-var:end/disp8 -17684 # otherwise append -17685 # var curr/eax: (addr stmt-var) = lookup(vars) -17686 (lookup *(ebp+0x14) *(ebp+0x18)) # => eax -17687 # while (curr->next != null) curr = curr->next -17688 { -17689 81 7/subop/compare *(eax+8) 0/imm32 # Stmt-var-next -17690 74/jump-if-= break/disp8 -17691 # curr = lookup(curr->next) -17692 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next, Stmt-var-next => eax -17693 # -17694 eb/jump loop/disp8 -17695 } -17696 # curr->next = out -17697 8b/-> *edi 1/r32/ecx -17698 89/<- *(eax+8) 1/r32/ecx # Stmt-var-next -17699 8b/-> *(edi+4) 1/r32/ecx -17700 89/<- *(eax+0xc) 1/r32/ecx # Stmt-var-next -17701 # out = vars -17702 8b/-> *(ebp+0x14) 1/r32/ecx -17703 89/<- *edi 1/r32/ecx -17704 8b/-> *(ebp+0x18) 1/r32/ecx -17705 89/<- *(edi+4) 1/r32/ecx -17706 $append-stmt-var:end: -17707 # . restore registers -17708 5f/pop-to-edi -17709 59/pop-to-ecx -17710 58/pop-to-eax -17711 # . epilogue -17712 89/<- %esp 5/r32/ebp -17713 5d/pop-to-ebp -17714 c3/return -17715 -17716 append-to-block: # ad: (addr allocation-descriptor), block: (addr block), x: (handle stmt) -17717 # . prologue -17718 55/push-ebp -17719 89/<- %ebp 4/r32/esp -17720 # . save registers -17721 50/push-eax -17722 56/push-esi -17723 # esi = block -17724 8b/-> *(ebp+0xc) 6/r32/esi -17725 # block->stmts = append(x, block->stmts) -17726 8d/copy-address *(esi+4) 0/r32/eax # Block-stmts -17727 (append-list *(ebp+8) *(ebp+0x10) *(ebp+0x14) *(esi+4) *(esi+8) %eax) # ad, x, x, Block-stmts, Block-stmts -17728 $append-to-block:end: -17729 # . restore registers -17730 5e/pop-to-esi -17731 58/pop-to-eax -17732 # . epilogue -17733 89/<- %esp 5/r32/ebp -17734 5d/pop-to-ebp -17735 c3/return -17736 -17737 ## Parsing types -17738 # We need to create metadata on user-defined types, and we need to use this -17739 # metadata as we parse instructions. -17740 # However, we also want to allow types to be used before their definitions. -17741 # This means we can't ever assume any type data structures exist. -17742 -17743 lookup-or-create-constant: # container: (addr stmt-var), field-name: (addr slice), out: (addr handle var) -17744 # . prologue -17745 55/push-ebp -17746 89/<- %ebp 4/r32/esp -17747 # . save registers -17748 50/push-eax -17749 56/push-esi -17750 # var container-type/esi: type-id -17751 (container-type *(ebp+8)) # => eax -17752 89/<- %esi 0/r32/eax -17753 # var tmp/eax: (handle typeinfo) = find-or-create-typeinfo(container-type) -17754 68/push 0/imm32 -17755 68/push 0/imm32 -17756 89/<- %eax 4/r32/esp -17757 (find-or-create-typeinfo %esi %eax) -17758 # var tmp-addr/eax: (addr typeinfo) = lookup(tmp) -17759 (lookup *eax *(eax+4)) # => eax -17760 # result = find-or-create-typeinfo-output-var(typeinfo, field-name) -17761 #? (write-buffered Stderr "constant: ") -17762 #? (write-slice-buffered Stderr *(ebp+0xc)) -17763 #? (write-buffered Stderr Newline) -17764 #? (flush Stderr) -17765 (find-or-create-typeinfo-output-var %eax *(ebp+0xc) *(ebp+0x10)) -17766 #? 8b/-> *(ebp+0x10) 0/r32/eax -17767 #? (write-buffered Stderr "@") -17768 #? (lookup *eax *(eax+4)) -17769 #? (write-int32-hex-buffered Stderr %eax) -17770 #? (lookup *eax *(eax+4)) -17771 #? (write-buffered Stderr %eax) -17772 #? (write-buffered Stderr Newline) -17773 #? (flush Stderr) -17774 #? (write-buffered Stderr "offset: ") -17775 #? 8b/-> *(eax+0x14) 0/r32/eax -17776 #? (write-int32-hex-buffered Stderr %eax) -17777 #? (write-buffered Stderr Newline) -17778 #? (flush Stderr) -17779 $lookup-or-create-constant:end: -17780 # . reclaim locals -17781 81 0/subop/add %esp 8/imm32 -17782 # . restore registers -17783 5e/pop-to-esi -17784 58/pop-to-eax -17785 # . epilogue -17786 89/<- %esp 5/r32/ebp -17787 5d/pop-to-ebp -17788 c3/return -17789 -17790 # if addr var: -17791 # container->var->type->right->left->value -17792 # otherwise -17793 # container->var->type->value -17794 container-type: # container: (addr stmt-var) -> result/eax: type-id -17795 # . prologue -17796 55/push-ebp -17797 89/<- %ebp 4/r32/esp -17798 # -17799 8b/-> *(ebp+8) 0/r32/eax -17800 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -17801 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -17802 { -17803 81 7/subop/compare *(eax+8) 0/imm32 # Type-tree-right -17804 74/jump-if-= break/disp8 -17805 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -17806 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -17807 } -17808 8b/-> *(eax+4) 0/r32/eax # Type-tree-value -17809 $container-type:end: -17810 # . epilogue -17811 89/<- %esp 5/r32/ebp -17812 5d/pop-to-ebp -17813 c3/return -17814 -17815 is-container?: # t: type-id -> result/eax: boolean -17816 # . prologue -17817 55/push-ebp -17818 89/<- %ebp 4/r32/esp -17819 # -17820 8b/-> *(ebp+8) 0/r32/eax -17821 c1/shift 4/subop/left %eax 2/imm8 -17822 3b/compare 0/r32/eax *Primitive-type-ids -17823 0f 9d/set-if->= %al -17824 81 4/subop/and %eax 0xff/imm32 -17825 $is-container?:end: -17826 # . epilogue -17827 89/<- %esp 5/r32/ebp -17828 5d/pop-to-ebp -17829 c3/return -17830 -17831 find-or-create-typeinfo: # t: type-id, out: (addr handle typeinfo) -17832 # . prologue -17833 55/push-ebp -17834 89/<- %ebp 4/r32/esp -17835 # . save registers -17836 50/push-eax -17837 51/push-ecx -17838 52/push-edx -17839 57/push-edi -17840 # edi = out -17841 8b/-> *(ebp+0xc) 7/r32/edi -17842 # var fields/ecx: (handle table (handle array byte) (handle typeinfo-entry)) -17843 68/push 0/imm32 -17844 68/push 0/imm32 -17845 89/<- %ecx 4/r32/esp -17846 # find-typeinfo(t, out) -17847 (find-typeinfo *(ebp+8) %edi) -17848 { -17849 # if (*out != 0) break -17850 81 7/subop/compare *edi 0/imm32 -17851 0f 85/jump-if-!= break/disp32 -17852 $find-or-create-typeinfo:create: -17853 # *out = allocate -17854 (allocate Heap *Typeinfo-size %edi) -17855 # var tmp/eax: (addr typeinfo) = lookup(*out) -17856 (lookup *edi *(edi+4)) # => eax -17857 #? (write-buffered Stderr "created typeinfo at ") -17858 #? (write-int32-hex-buffered Stderr %eax) -17859 #? (write-buffered Stderr " for type-id ") -17860 #? (write-int32-hex-buffered Stderr *(ebp+8)) -17861 #? (write-buffered Stderr Newline) -17862 #? (flush Stderr) -17863 # tmp->id = t -17864 8b/-> *(ebp+8) 2/r32/edx -17865 89/<- *eax 2/r32/edx # Typeinfo-id -17866 # tmp->fields = new table -17867 # . fields = new table -17868 (new-stream Heap 0x40 *Typeinfo-fields-row-size %ecx) -17869 # . tmp->fields = fields -17870 8b/-> *ecx 2/r32/edx -17871 89/<- *(eax+4) 2/r32/edx # Typeinfo-fields -17872 8b/-> *(ecx+4) 2/r32/edx -17873 89/<- *(eax+8) 2/r32/edx # Typeinfo-fields -17874 # tmp->next = Program->types -17875 8b/-> *_Program-types 1/r32/ecx -17876 89/<- *(eax+0x10) 1/r32/ecx # Typeinfo-next -17877 8b/-> *_Program-types->payload 1/r32/ecx -17878 89/<- *(eax+0x14) 1/r32/ecx # Typeinfo-next -17879 # Program->types = out -17880 8b/-> *edi 1/r32/ecx -17881 89/<- *_Program-types 1/r32/ecx -17882 8b/-> *(edi+4) 1/r32/ecx -17883 89/<- *_Program-types->payload 1/r32/ecx -17884 } -17885 $find-or-create-typeinfo:end: -17886 # . reclaim locals -17887 81 0/subop/add %esp 8/imm32 -17888 # . restore registers -17889 5f/pop-to-edi -17890 5a/pop-to-edx -17891 59/pop-to-ecx -17892 58/pop-to-eax -17893 # . epilogue -17894 89/<- %esp 5/r32/ebp -17895 5d/pop-to-ebp -17896 c3/return -17897 -17898 find-typeinfo: # t: type-id, out: (addr handle typeinfo) -17899 # . prologue -17900 55/push-ebp -17901 89/<- %ebp 4/r32/esp -17902 # . save registers -17903 50/push-eax -17904 51/push-ecx -17905 52/push-edx -17906 57/push-edi -17907 # ecx = t -17908 8b/-> *(ebp+8) 1/r32/ecx -17909 # edi = out -17910 8b/-> *(ebp+0xc) 7/r32/edi -17911 # *out = Program->types -17912 8b/-> *_Program-types 0/r32/eax -17913 89/<- *edi 0/r32/eax -17914 8b/-> *_Program-types->payload 0/r32/eax -17915 89/<- *(edi+4) 0/r32/eax -17916 { -17917 $find-typeinfo:loop: -17918 # if (*out == 0) break -17919 81 7/subop/compare *edi 0/imm32 -17920 74/jump-if-= break/disp8 -17921 $find-typeinfo:check: -17922 # var tmp/eax: (addr typeinfo) = lookup(*out) -17923 (lookup *edi *(edi+4)) # => eax -17924 # if (tmp->id == t) break -17925 39/compare *eax 1/r32/ecx # Typeinfo-id -17926 74/jump-if-= break/disp8 -17927 $find-typeinfo:continue: -17928 # *out = tmp->next -17929 8b/-> *(eax+0x10) 2/r32/edx # Typeinfo-next -17930 89/<- *edi 2/r32/edx -17931 8b/-> *(eax+0x14) 2/r32/edx # Typeinfo-next -17932 89/<- *(edi+4) 2/r32/edx -17933 # -17934 eb/jump loop/disp8 -17935 } -17936 $find-typeinfo:end: -17937 # . restore registers -17938 5f/pop-to-edi -17939 5a/pop-to-edx -17940 59/pop-to-ecx -17941 58/pop-to-eax -17942 # . epilogue -17943 89/<- %esp 5/r32/ebp -17944 5d/pop-to-ebp -17945 c3/return -17946 -17947 find-or-create-typeinfo-output-var: # T: (addr typeinfo), f: (addr slice), out: (addr handle var) -17948 # . prologue -17949 55/push-ebp -17950 89/<- %ebp 4/r32/esp -17951 # . save registers -17952 50/push-eax -17953 52/push-edx -17954 57/push-edi -17955 # var dest/edi: (handle typeinfo-entry) -17956 68/push 0/imm32 -17957 68/push 0/imm32 -17958 89/<- %edi 4/r32/esp -17959 # find-or-create-typeinfo-fields(T, f, dest) -17960 (find-or-create-typeinfo-fields *(ebp+8) *(ebp+0xc) %edi) -17961 # var dest-addr/edi: (addr typeinfo-entry) = lookup(dest) -17962 (lookup *edi *(edi+4)) # => eax -17963 89/<- %edi 0/r32/eax -17964 # if dest-addr->output-var doesn't exist, create it -17965 { -17966 81 7/subop/compare *(edi+0xc) 0/imm32 # Typeinfo-entry-output-var -17967 0f 85/jump-if-!= break/disp32 -17968 # dest-addr->output-var = new var(dummy name, type, -1 offset) -17969 # . var name/eax: (handle array byte) = "field" -17970 68/push 0/imm32 -17971 68/push 0/imm32 -17972 89/<- %eax 4/r32/esp -17973 (slice-to-string Heap *(ebp+0xc) %eax) -17974 # . new var -17975 8d/copy-address *(edi+0xc) 2/r32/edx -17976 (new-var Heap *eax *(eax+4) %edx) -17977 # . reclaim name -17978 81 0/subop/add %esp 8/imm32 -17979 # var result/edx: (addr var) = lookup(dest-addr->output-var) -17980 (lookup *(edi+0xc) *(edi+0x10)) # => eax -17981 89/<- %edx 0/r32/eax -17982 # result->type = new constant type -17983 8d/copy-address *(edx+8) 0/r32/eax # Var-type -17984 (allocate Heap *Type-tree-size %eax) -17985 (lookup *(edx+8) *(edx+0xc)) # => eax -17986 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom -17987 c7 0/subop/copy *(eax+4) 6/imm32/constant # Type-tree-value -17988 c7 0/subop/copy *(eax+8) 0/imm32 # Type-tree-left -17989 c7 0/subop/copy *(eax+0xc) 0/imm32 # Type-tree-right -17990 c7 0/subop/copy *(eax+0x10) 0/imm32 # Type-tree-right -17991 # result->offset isn't filled out yet -17992 c7 0/subop/copy *(edx+0x14) -1/imm32/uninitialized # Var-offset -17993 } -17994 # out = dest-addr->output-var -17995 8b/-> *(ebp+0x10) 2/r32/edx -17996 8b/-> *(edi+0xc) 0/r32/eax # Typeinfo-entry-output-var -17997 89/<- *edx 0/r32/eax -17998 8b/-> *(edi+0x10) 0/r32/eax # Typeinfo-entry-output-var -17999 89/<- *(edx+4) 0/r32/eax -18000 $find-or-create-typeinfo-output-var:end: -18001 # . reclaim locals -18002 81 0/subop/add %esp 8/imm32 -18003 # . restore registers -18004 5f/pop-to-edi -18005 5a/pop-to-edx -18006 58/pop-to-eax -18007 # . epilogue -18008 89/<- %esp 5/r32/ebp -18009 5d/pop-to-ebp -18010 c3/return -18011 -18012 find-or-create-typeinfo-fields: # T: (addr typeinfo), f: (addr slice), out: (addr handle typeinfo-entry) -18013 # . prologue -18014 55/push-ebp -18015 89/<- %ebp 4/r32/esp -18016 # . save registers -18017 50/push-eax -18018 56/push-esi -18019 57/push-edi -18020 # eax = lookup(T->fields) -18021 8b/-> *(ebp+8) 0/r32/eax -18022 (lookup *(eax+4) *(eax+8)) # Typeinfo-fields Typeinfo-fields => eax -18023 # edi = out -18024 8b/-> *(ebp+0x10) 7/r32/edi -18025 # var src/esi: (addr handle typeinfo-entry) = get-or-insert-slice(T->fields, f) -18026 (get-or-insert-slice %eax *(ebp+0xc) *Typeinfo-fields-row-size Heap) # => eax -18027 89/<- %esi 0/r32/eax -18028 # if src doesn't exist, allocate it -18029 { -18030 81 7/subop/compare *esi 0/imm32 -18031 75/jump-if-!= break/disp8 -18032 (allocate Heap *Typeinfo-entry-size %esi) -18033 #? (write-buffered Stderr "handle at ") -18034 #? (write-int32-hex-buffered Stderr %esi) -18035 #? (write-buffered Stderr ": ") -18036 #? (write-int32-hex-buffered Stderr *esi) -18037 #? (write-buffered Stderr " ") -18038 #? (write-int32-hex-buffered Stderr *(esi+4)) -18039 #? (write-buffered Stderr Newline) -18040 #? (flush Stderr) -18041 #? (lookup *esi *(esi+4)) -18042 #? (write-buffered Stderr "created typeinfo fields at ") -18043 #? (write-int32-hex-buffered Stderr %esi) -18044 #? (write-buffered Stderr " for ") -18045 #? (write-int32-hex-buffered Stderr *(ebp+8)) -18046 #? (write-buffered Stderr Newline) -18047 #? (flush Stderr) -18048 } -18049 # *out = src -18050 # . *edi = *src -18051 8b/-> *esi 0/r32/eax -18052 89/<- *edi 0/r32/eax -18053 8b/-> *(esi+4) 0/r32/eax -18054 89/<- *(edi+4) 0/r32/eax -18055 $find-or-create-typeinfo-fields:end: +17600 $lookup-var-or-literal:abort: +17601 (write-buffered *(ebp+0x18) "fn ") +17602 8b/-> *(ebp+0x14) 0/r32/eax +17603 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17604 (write-buffered *(ebp+0x18) %eax) +17605 (write-buffered *(ebp+0x18) ": empty variable!") +17606 (flush *(ebp+0x18)) +17607 (stop *(ebp+0x1c) 1) +17608 # never gets here +17609 +17610 # return first 'name' from the top (back) of 'vars' and abort if not found +17611 lookup-var: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +17612 # . prologue +17613 55/push-ebp +17614 89/<- %ebp 4/r32/esp +17615 # . save registers +17616 50/push-eax +17617 # +17618 (lookup-var-helper *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +17619 # if (*out == 0) abort +17620 8b/-> *(ebp+0x10) 0/r32/eax +17621 81 7/subop/compare *eax 0/imm32 +17622 74/jump-if-= $lookup-var:abort/disp8 +17623 $lookup-var:end: +17624 # . restore registers +17625 58/pop-to-eax +17626 # . epilogue +17627 89/<- %esp 5/r32/ebp +17628 5d/pop-to-ebp +17629 c3/return +17630 +17631 $lookup-var:abort: +17632 (write-buffered *(ebp+0x18) "fn ") +17633 8b/-> *(ebp+0x14) 0/r32/eax +17634 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17635 (write-buffered *(ebp+0x18) %eax) +17636 (write-buffered *(ebp+0x18) ": unknown variable '") +17637 (write-slice-buffered *(ebp+0x18) *(ebp+8)) +17638 (write-buffered *(ebp+0x18) "'\n") +17639 (flush *(ebp+0x18)) +17640 (stop *(ebp+0x1c) 1) +17641 # never gets here +17642 +17643 # return first 'name' from the top (back) of 'vars', and 0/null if not found +17644 # ensure that 'name' if in a register is the topmost variable in that register +17645 lookup-var-helper: # name: (addr slice), vars: (addr stack live-var), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +17646 # pseudocode: +17647 # var curr: (addr handle var) = &vars->data[vars->top - 12] +17648 # var min = vars->data +17649 # while curr >= min +17650 # var v: (handle var) = *curr +17651 # if v->name == name +17652 # return +17653 # curr -= 12 +17654 # +17655 # . prologue +17656 55/push-ebp +17657 89/<- %ebp 4/r32/esp +17658 # . save registers +17659 50/push-eax +17660 51/push-ecx +17661 52/push-edx +17662 53/push-ebx +17663 56/push-esi +17664 57/push-edi +17665 # clear out +17666 (zero-out *(ebp+0x10) *Handle-size) +17667 # esi = vars +17668 8b/-> *(ebp+0xc) 6/r32/esi +17669 # ebx = vars->top +17670 8b/-> *esi 3/r32/ebx +17671 # if (vars->top > vars->size) abort +17672 3b/compare<- *(esi+4) 0/r32/eax +17673 0f 8f/jump-if-> $lookup-var-helper:error1/disp32 +17674 # var min/edx: (addr handle var) = vars->data +17675 8d/copy-address *(esi+8) 2/r32/edx +17676 # var curr/ebx: (addr handle var) = &vars->data[vars->top - 12] +17677 8d/copy-address *(esi+ebx-4) 3/r32/ebx # vars + 8 + vars->type - 12 +17678 # var var-in-reg/edi: 16 addrs +17679 68/push 0/imm32 +17680 68/push 0/imm32 +17681 68/push 0/imm32 +17682 68/push 0/imm32 +17683 68/push 0/imm32 +17684 68/push 0/imm32 +17685 68/push 0/imm32 +17686 68/push 0/imm32 +17687 68/push 0/imm32 +17688 68/push 0/imm32 +17689 68/push 0/imm32 +17690 68/push 0/imm32 +17691 68/push 0/imm32 +17692 68/push 0/imm32 +17693 68/push 0/imm32 +17694 68/push 0/imm32 +17695 89/<- %edi 4/r32/esp +17696 { +17697 $lookup-var-helper:loop: +17698 # if (curr < min) return +17699 39/compare %ebx 2/r32/edx +17700 0f 82/jump-if-addr< break/disp32 +17701 # var v/ecx: (addr var) = lookup(*curr) +17702 (lookup *ebx *(ebx+4)) # => eax +17703 89/<- %ecx 0/r32/eax +17704 # var vn/eax: (addr array byte) = lookup(v->name) +17705 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +17706 # if (vn == name) return curr +17707 (slice-equal? *(ebp+8) %eax) # => eax +17708 3d/compare-eax-and 0/imm32/false +17709 { +17710 74/jump-if-= break/disp8 +17711 $lookup-var-helper:found: +17712 # var vr/eax: (addr array byte) = lookup(v->register) +17713 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax +17714 3d/compare-eax-and 0/imm32 +17715 { +17716 74/jump-if-= break/disp8 +17717 $lookup-var-helper:found-register: +17718 # var reg/eax: int = get(Registers, vr) +17719 (get Mu-registers-unique %eax 0xc "Mu-registers-unique") # => eax +17720 8b/-> *eax 0/r32/eax +17721 # if (var-in-reg[reg]) error +17722 8b/-> *(edi+eax<<2) 0/r32/eax +17723 3d/compare-eax-and 0/imm32 +17724 0f 85/jump-if-!= $lookup-var-helper:error2/disp32 +17725 } +17726 $lookup-var-helper:return: +17727 # esi = out +17728 8b/-> *(ebp+0x10) 6/r32/esi +17729 # *out = *curr +17730 8b/-> *ebx 0/r32/eax +17731 89/<- *esi 0/r32/eax +17732 8b/-> *(ebx+4) 0/r32/eax +17733 89/<- *(esi+4) 0/r32/eax +17734 # return +17735 eb/jump $lookup-var-helper:end/disp8 +17736 } +17737 # 'name' not yet found; update var-in-reg if v in register +17738 # . var vr/eax: (addr array byte) = lookup(v->register) +17739 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax +17740 # . if (vr == 0) continue +17741 3d/compare-eax-and 0/imm32 +17742 74/jump-if-= $lookup-var-helper:continue/disp8 +17743 # . var reg/eax: int = get(Registers, vr) +17744 (get Mu-registers-unique %eax 0xc "Mu-registers-unique") # => eax +17745 8b/-> *eax 0/r32/eax +17746 # . var-in-reg[reg] = v +17747 89/<- *(edi+eax<<2) 1/r32/ecx +17748 $lookup-var-helper:continue: +17749 # curr -= 12 +17750 81 5/subop/subtract %ebx 0xc/imm32 +17751 e9/jump loop/disp32 +17752 } +17753 $lookup-var-helper:end: +17754 # . reclaim locals +17755 81 0/subop/add %esp 0x40/imm32 +17756 # . restore registers +17757 5f/pop-to-edi +17758 5e/pop-to-esi +17759 5b/pop-to-ebx +17760 5a/pop-to-edx +17761 59/pop-to-ecx +17762 58/pop-to-eax +17763 # . epilogue +17764 89/<- %esp 5/r32/ebp +17765 5d/pop-to-ebp +17766 c3/return +17767 +17768 $lookup-var-helper:error1: +17769 (write-buffered *(ebp+0x18) "fn ") +17770 8b/-> *(ebp+0x14) 0/r32/eax +17771 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17772 (write-buffered *(ebp+0x18) %eax) +17773 (write-buffered *(ebp+0x18) ": malformed stack when looking up '") +17774 (write-slice-buffered *(ebp+0x18) *(ebp+8)) +17775 (write-buffered *(ebp+0x18) "'\n") +17776 (flush *(ebp+0x18)) +17777 (stop *(ebp+0x1c) 1) +17778 # never gets here +17779 +17780 $lookup-var-helper:error2: +17781 # eax contains the conflicting var at this point +17782 (write-buffered *(ebp+0x18) "fn ") +17783 50/push-eax +17784 8b/-> *(ebp+0x14) 0/r32/eax +17785 (lookup *eax *(eax+4)) # Function-name Function-name => eax +17786 (write-buffered *(ebp+0x18) %eax) +17787 58/pop-eax +17788 (write-buffered *(ebp+0x18) ": register ") +17789 50/push-eax +17790 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +17791 (write-buffered *(ebp+0x18) %eax) +17792 58/pop-to-eax +17793 (write-buffered *(ebp+0x18) " reads var '") +17794 (write-slice-buffered *(ebp+0x18) *(ebp+8)) +17795 (write-buffered *(ebp+0x18) "' after writing var '") +17796 (lookup *eax *(eax+4)) # Var-name Var-name => eax +17797 (write-buffered *(ebp+0x18) %eax) +17798 (write-buffered *(ebp+0x18) "'\n") +17799 (flush *(ebp+0x18)) +17800 (stop *(ebp+0x1c) 1) +17801 # never gets here +17802 +17803 dump-vars: # vars: (addr stack live-var) +17804 # pseudocode: +17805 # var curr: (addr handle var) = &vars->data[vars->top - 12] +17806 # var min = vars->data +17807 # while curr >= min +17808 # var v: (handle var) = *curr +17809 # print v +17810 # curr -= 12 +17811 # +17812 # . prologue +17813 55/push-ebp +17814 89/<- %ebp 4/r32/esp +17815 # . save registers +17816 52/push-edx +17817 53/push-ebx +17818 56/push-esi +17819 # esi = vars +17820 8b/-> *(ebp+8) 6/r32/esi +17821 # ebx = vars->top +17822 8b/-> *esi 3/r32/ebx +17823 # var min/edx: (addr handle var) = vars->data +17824 8d/copy-address *(esi+8) 2/r32/edx +17825 # var curr/ebx: (addr handle var) = &vars->data[vars->top - 12] +17826 8d/copy-address *(esi+ebx-4) 3/r32/ebx # vars + 8 + vars->type - 12 +17827 { +17828 $dump-vars:loop: +17829 # if (curr < min) return +17830 39/compare %ebx 2/r32/edx +17831 0f 82/jump-if-addr< break/disp32 +17832 # +17833 (write-buffered Stderr " var@") +17834 (dump-var 2 %ebx) +17835 # curr -= 12 +17836 81 5/subop/subtract %ebx 0xc/imm32 +17837 e9/jump loop/disp32 +17838 } +17839 $dump-vars:end: +17840 # . restore registers +17841 5e/pop-to-esi +17842 5b/pop-to-ebx +17843 5a/pop-to-edx +17844 # . epilogue +17845 89/<- %esp 5/r32/ebp +17846 5d/pop-to-ebp +17847 c3/return +17848 +17849 == data +17850 # Like Registers, but no esp or ebp +17851 Mu-registers: # (addr stream {(handle array byte), int}) +17852 # a table is a stream +17853 0xa8/imm32/write +17854 0/imm32/read +17855 0xa8/imm32/length +17856 # data +17857 # general-purpose registers +17858 # it is perfectly ok to use fake alloc-ids -- as long as you never try to reclaim them +17859 0x11/imm32/alloc-id $Mu-register-eax/imm32 0/imm32 +17860 0x11/imm32/alloc-id $Mu-register-ecx/imm32 1/imm32 +17861 0x11/imm32/alloc-id $Mu-register-edx/imm32 2/imm32 +17862 0x11/imm32/alloc-id $Mu-register-ebx/imm32 3/imm32 +17863 0x11/imm32/alloc-id $Mu-register-esi/imm32 6/imm32 +17864 0x11/imm32/alloc-id $Mu-register-edi/imm32 7/imm32 +17865 # floating-point registers +17866 0x11/imm32/alloc-id $Mu-register-xmm0/imm32 0/imm32 +17867 0x11/imm32/alloc-id $Mu-register-xmm1/imm32 1/imm32 +17868 0x11/imm32/alloc-id $Mu-register-xmm2/imm32 2/imm32 +17869 0x11/imm32/alloc-id $Mu-register-xmm3/imm32 3/imm32 +17870 0x11/imm32/alloc-id $Mu-register-xmm4/imm32 4/imm32 +17871 0x11/imm32/alloc-id $Mu-register-xmm5/imm32 5/imm32 +17872 0x11/imm32/alloc-id $Mu-register-xmm6/imm32 6/imm32 +17873 0x11/imm32/alloc-id $Mu-register-xmm7/imm32 7/imm32 +17874 +17875 # Like Mu-registers, but with unique codes for integer and floating-point +17876 # registers. +17877 # Don't use this for code-generation, only for checking. +17878 Mu-registers-unique: # (addr stream {(handle array byte), int}) +17879 # a table is a stream +17880 0xa8/imm32/write +17881 0/imm32/read +17882 0xa8/imm32/length +17883 # data +17884 # general-purpose registers +17885 0x11/imm32/alloc-id $Mu-register-eax/imm32 0/imm32 +17886 0x11/imm32/alloc-id $Mu-register-ecx/imm32 1/imm32 +17887 0x11/imm32/alloc-id $Mu-register-edx/imm32 2/imm32 +17888 0x11/imm32/alloc-id $Mu-register-ebx/imm32 3/imm32 +17889 0x11/imm32/alloc-id $Mu-register-esi/imm32 6/imm32 +17890 0x11/imm32/alloc-id $Mu-register-edi/imm32 7/imm32 +17891 # floating-point registers +17892 0x11/imm32/alloc-id $Mu-register-xmm0/imm32 8/imm32 +17893 0x11/imm32/alloc-id $Mu-register-xmm1/imm32 9/imm32 +17894 0x11/imm32/alloc-id $Mu-register-xmm2/imm32 0xa/imm32 +17895 0x11/imm32/alloc-id $Mu-register-xmm3/imm32 0xb/imm32 +17896 0x11/imm32/alloc-id $Mu-register-xmm4/imm32 0xc/imm32 +17897 0x11/imm32/alloc-id $Mu-register-xmm5/imm32 0xd/imm32 +17898 0x11/imm32/alloc-id $Mu-register-xmm6/imm32 0xe/imm32 +17899 0x11/imm32/alloc-id $Mu-register-xmm7/imm32 0xf/imm32 +17900 +17901 $Mu-register-eax: +17902 0x11/imm32/alloc-id +17903 3/imm32/size +17904 0x65/e 0x61/a 0x78/x +17905 +17906 $Mu-register-ecx: +17907 0x11/imm32/alloc-id +17908 3/imm32/size +17909 0x65/e 0x63/c 0x78/x +17910 +17911 $Mu-register-edx: +17912 0x11/imm32/alloc-id +17913 3/imm32/size +17914 0x65/e 0x64/d 0x78/x +17915 +17916 $Mu-register-ebx: +17917 0x11/imm32/alloc-id +17918 3/imm32/size +17919 0x65/e 0x62/b 0x78/x +17920 +17921 $Mu-register-esi: +17922 0x11/imm32/alloc-id +17923 3/imm32/size +17924 0x65/e 0x73/s 0x69/i +17925 +17926 $Mu-register-edi: +17927 0x11/imm32/alloc-id +17928 3/imm32/size +17929 0x65/e 0x64/d 0x69/i +17930 +17931 $Mu-register-xmm0: +17932 0x11/imm32/alloc-id:fake:payload +17933 # "xmm0" +17934 0x4/imm32/size +17935 0x78/x 0x6d/m 0x6d/m 0x30/0 +17936 +17937 $Mu-register-xmm1: +17938 0x11/imm32/alloc-id:fake:payload +17939 # "xmm1" +17940 0x4/imm32/size +17941 0x78/x 0x6d/m 0x6d/m 0x31/1 +17942 +17943 $Mu-register-xmm2: +17944 0x11/imm32/alloc-id:fake:payload +17945 # "xmm2" +17946 0x4/imm32/size +17947 0x78/x 0x6d/m 0x6d/m 0x32/2 +17948 +17949 $Mu-register-xmm3: +17950 0x11/imm32/alloc-id:fake:payload +17951 # "xmm3" +17952 0x4/imm32/size +17953 0x78/x 0x6d/m 0x6d/m 0x33/3 +17954 +17955 $Mu-register-xmm4: +17956 0x11/imm32/alloc-id:fake:payload +17957 # "xmm4" +17958 0x4/imm32/size +17959 0x78/x 0x6d/m 0x6d/m 0x34/4 +17960 +17961 $Mu-register-xmm5: +17962 0x11/imm32/alloc-id:fake:payload +17963 # "xmm5" +17964 0x4/imm32/size +17965 0x78/x 0x6d/m 0x6d/m 0x35/5 +17966 +17967 $Mu-register-xmm6: +17968 0x11/imm32/alloc-id:fake:payload +17969 # "xmm6" +17970 0x4/imm32/size +17971 0x78/x 0x6d/m 0x6d/m 0x36/6 +17972 +17973 $Mu-register-xmm7: +17974 0x11/imm32/alloc-id:fake:payload +17975 # "xmm7" +17976 0x4/imm32/size +17977 0x78/x 0x6d/m 0x6d/m 0x37/7 +17978 +17979 == code +17980 +17981 # push 'out' to 'vars' if not already there; it's assumed to be a fn output +17982 maybe-define-var: # out: (handle var), vars: (addr stack live-var) +17983 # . prologue +17984 55/push-ebp +17985 89/<- %ebp 4/r32/esp +17986 # . save registers +17987 50/push-eax +17988 # var out-addr/eax: (addr var) +17989 (lookup *(ebp+8) *(ebp+0xc)) # => eax +17990 # +17991 (binding-exists? %eax *(ebp+0x10)) # => eax +17992 3d/compare-eax-and 0/imm32/false +17993 75/jump-if-!= $maybe-define-var:end/disp8 +17994 # otherwise update vars +17995 (push *(ebp+0x10) *(ebp+8)) +17996 (push *(ebp+0x10) *(ebp+0xc)) +17997 (push *(ebp+0x10) 0) # 'out' is always a fn output; never spill it +17998 $maybe-define-var:end: +17999 # . restore registers +18000 58/pop-to-eax +18001 # . epilogue +18002 89/<- %esp 5/r32/ebp +18003 5d/pop-to-ebp +18004 c3/return +18005 +18006 # simpler version of lookup-var-helper +18007 binding-exists?: # target: (addr var), vars: (addr stack live-var) -> result/eax: boolean +18008 # pseudocode: +18009 # var curr: (addr handle var) = &vars->data[vars->top - 12] +18010 # var min = vars->data +18011 # while curr >= min +18012 # var v: (handle var) = *curr +18013 # if v->name == target->name +18014 # return true +18015 # curr -= 12 +18016 # return false +18017 # +18018 # . prologue +18019 55/push-ebp +18020 89/<- %ebp 4/r32/esp +18021 # . save registers +18022 51/push-ecx +18023 52/push-edx +18024 56/push-esi +18025 # var target-name/ecx: (addr array byte) = lookup(target->name) +18026 8b/-> *(ebp+8) 0/r32/eax +18027 (lookup *eax *(eax+4)) # Var-name Var-name => eax +18028 89/<- %ecx 0/r32/eax +18029 # esi = vars +18030 8b/-> *(ebp+0xc) 6/r32/esi +18031 # eax = vars->top +18032 8b/-> *esi 0/r32/eax +18033 # var min/edx: (addr handle var) = vars->data +18034 8d/copy-address *(esi+8) 2/r32/edx +18035 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] +18036 8d/copy-address *(esi+eax-4) 6/r32/esi # vars + 8 + vars->type - 12 +18037 { +18038 $binding-exists?:loop: +18039 # if (curr < min) return +18040 39/compare %esi 2/r32/edx +18041 0f 82/jump-if-addr< break/disp32 +18042 # var v/eax: (addr var) = lookup(*curr) +18043 (lookup *esi *(esi+4)) # => eax +18044 # var vn/eax: (addr array byte) = lookup(v->name) +18045 (lookup *eax *(eax+4)) # Var-name Var-name => eax +18046 # if (vn == target-name) return true +18047 (string-equal? %ecx %eax) # => eax +18048 3d/compare-eax-and 0/imm32/false +18049 75/jump-if-!= $binding-exists?:end/disp8 # eax already contains true +18050 # curr -= 12 +18051 81 5/subop/subtract %esi 0xc/imm32 +18052 e9/jump loop/disp32 +18053 } +18054 b8/copy-to-eax 0/imm32/false +18055 $binding-exists?:end: 18056 # . restore registers -18057 5f/pop-to-edi -18058 5e/pop-to-esi -18059 58/pop-to-eax +18057 5e/pop-to-esi +18058 5a/pop-to-edx +18059 59/pop-to-ecx 18060 # . epilogue 18061 89/<- %esp 5/r32/ebp 18062 5d/pop-to-ebp 18063 c3/return 18064 -18065 populate-mu-type: # in: (addr stream byte), t: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) -18066 # pseudocode: -18067 # var line: (stream byte 512) -18068 # curr-index = 0 -18069 # while true -18070 # clear-stream(line) -18071 # read-line-buffered(in, line) -18072 # if line->write == 0 -18073 # abort -18074 # word-slice = next-mu-token(line) -18075 # if slice-empty?(word-slice) # end of line -18076 # continue -18077 # if slice-equal?(word-slice, "}") -18078 # break -18079 # var v: (handle var) = parse-var-with-type(word-slice, line) -18080 # var r: (handle typeinfo-fields) = find-or-create-typeinfo-fields(t, word-slice/v->name) -18081 # TODO: ensure that r->first is null -18082 # r->index = curr-index -18083 # curr-index++ -18084 # r->input-var = v -18085 # if r->output-var == 0 -18086 # r->output-var = new literal -18087 # TODO: ensure nothing else in line -18088 # t->total-size-in-bytes = -2 (not yet initialized) -18089 # -18090 # . prologue -18091 55/push-ebp -18092 89/<- %ebp 4/r32/esp -18093 # var curr-index: int at *(ebp-4) -18094 68/push 0/imm32 -18095 # . save registers -18096 50/push-eax -18097 51/push-ecx -18098 52/push-edx -18099 53/push-ebx -18100 56/push-esi -18101 57/push-edi -18102 # edi = t -18103 8b/-> *(ebp+0xc) 7/r32/edi -18104 # var line/ecx: (stream byte 512) -18105 81 5/subop/subtract %esp 0x200/imm32 -18106 68/push 0x200/imm32/size -18107 68/push 0/imm32/read -18108 68/push 0/imm32/write -18109 89/<- %ecx 4/r32/esp -18110 # var word-slice/edx: slice -18111 68/push 0/imm32/end -18112 68/push 0/imm32/start -18113 89/<- %edx 4/r32/esp -18114 # var v/esi: (handle var) -18115 68/push 0/imm32 -18116 68/push 0/imm32 -18117 89/<- %esi 4/r32/esp -18118 # var r/ebx: (handle typeinfo-entry) -18119 68/push 0/imm32 -18120 68/push 0/imm32 -18121 89/<- %ebx 4/r32/esp -18122 { -18123 $populate-mu-type:line-loop: -18124 (clear-stream %ecx) -18125 (read-line-buffered *(ebp+8) %ecx) -18126 # if (line->write == 0) abort -18127 81 7/subop/compare *ecx 0/imm32 -18128 0f 84/jump-if-= $populate-mu-type:error1/disp32 -18129 +-- 6 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -18135 (next-mu-token %ecx %edx) -18136 # if slice-empty?(word-slice) continue -18137 (slice-empty? %edx) # => eax -18138 3d/compare-eax-and 0/imm32 -18139 0f 85/jump-if-!= loop/disp32 -18140 # if slice-equal?(word-slice, "}") break -18141 (slice-equal? %edx "}") -18142 3d/compare-eax-and 0/imm32 -18143 0f 85/jump-if-!= break/disp32 -18144 $populate-mu-type:parse-element: -18145 # v = parse-var-with-type(word-slice, first-line) -18146 # must do this first to strip the trailing ':' from word-slice before -18147 # using it in find-or-create-typeinfo-fields below -18148 # TODO: clean up that mutation in parse-var-with-type -18149 (parse-var-with-type %edx %ecx %esi *(ebp+0x10) *(ebp+0x14)) -18150 # if v is an addr, abort -18151 (lookup *esi *(esi+4)) # => eax -18152 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -18153 (is-mu-addr-type? %eax) # => eax -18154 3d/compare-eax-and 0/imm32/false -18155 0f 85/jump-if-!= $populate-mu-type:error2/disp32 -18156 # if v is an array, abort (we could support it, but initialization gets complex) -18157 (lookup *esi *(esi+4)) # => eax -18158 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -18159 (is-mu-array-type? %eax) # => eax -18160 3d/compare-eax-and 0/imm32/false -18161 0f 85/jump-if-!= $populate-mu-type:error3/disp32 -18162 # if v is a byte, abort -18163 (lookup *esi *(esi+4)) # => eax -18164 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -18165 (is-simple-mu-type? %eax 8) # byte => eax -18166 3d/compare-eax-and 0/imm32/false -18167 0f 85/jump-if-!= $populate-mu-type:error4/disp32 -18168 # if v is a slice, abort -18169 (lookup *esi *(esi+4)) # => eax -18170 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -18171 (is-simple-mu-type? %eax 0xc) # slice => eax -18172 3d/compare-eax-and 0/imm32/false -18173 0f 85/jump-if-!= $populate-mu-type:error5/disp32 -18174 # if v is a stream, abort (we could support it, but initialization gets even more complex) -18175 (lookup *esi *(esi+4)) # => eax -18176 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -18177 (is-mu-stream-type? %eax) # => eax -18178 3d/compare-eax-and 0/imm32/false -18179 0f 85/jump-if-!= $populate-mu-type:error6/disp32 -18180 # var tmp/ecx -18181 51/push-ecx -18182 $populate-mu-type:create-typeinfo-fields: -18183 # var r/ebx: (handle typeinfo-entry) -18184 (find-or-create-typeinfo-fields %edi %edx %ebx) -18185 # r->index = curr-index -18186 (lookup *ebx *(ebx+4)) # => eax -18187 8b/-> *(ebp-4) 1/r32/ecx -18188 #? (write-buffered Stderr "saving index ") -18189 #? (write-int32-hex-buffered Stderr %ecx) -18190 #? (write-buffered Stderr " at ") -18191 #? (write-int32-hex-buffered Stderr %edi) -18192 #? (write-buffered Stderr Newline) -18193 #? (flush Stderr) -18194 89/<- *(eax+8) 1/r32/ecx # Typeinfo-entry-index -18195 # ++curr-index -18196 ff 0/subop/increment *(ebp-4) -18197 $populate-mu-type:set-input-type: -18198 # r->input-var = v -18199 8b/-> *esi 1/r32/ecx -18200 89/<- *eax 1/r32/ecx # Typeinfo-entry-input-var -18201 8b/-> *(esi+4) 1/r32/ecx -18202 89/<- *(eax+4) 1/r32/ecx # Typeinfo-entry-input-var -18203 # restore line -18204 59/pop-to-ecx -18205 { -18206 $populate-mu-type:create-output-type: -18207 # if (r->output-var == 0) create a new var with some placeholder data -18208 81 7/subop/compare *(eax+0xc) 0/imm32 # Typeinfo-entry-output-var -18209 75/jump-if-!= break/disp8 -18210 8d/copy-address *(eax+0xc) 0/r32/eax # Typeinfo-entry-output-var -18211 (new-literal Heap %edx %eax) -18212 } -18213 e9/jump loop/disp32 -18214 } -18215 $populate-mu-type:invalidate-total-size-in-bytes: -18216 # Offsets and total size may not be accurate here since we may not yet -18217 # have encountered the element types. -18218 # We'll recompute them separately after parsing the entire program. -18219 c7 0/subop/copy *(edi+0xc) -2/imm32/uninitialized # Typeinfo-total-size-in-bytes -18220 $populate-mu-type:end: -18221 # . reclaim locals -18222 81 0/subop/add %esp 0x224/imm32 -18223 # . restore registers -18224 5f/pop-to-edi -18225 5e/pop-to-esi -18226 5b/pop-to-ebx -18227 5a/pop-to-edx -18228 59/pop-to-ecx -18229 58/pop-to-eax -18230 # reclaim curr-index -18231 81 0/subop/add %esp 4/imm32 -18232 # . epilogue -18233 89/<- %esp 5/r32/ebp -18234 5d/pop-to-ebp -18235 c3/return -18236 -18237 $populate-mu-type:error1: -18238 # error("incomplete type definition '" t->name "'\n") -18239 (write-buffered *(ebp+0x10) "incomplete type definition '") -18240 (type-name *edi) # Typeinfo-id => eax -18241 (write-buffered *(ebp+0x10) %eax) -18242 (write-buffered *(ebp+0x10) "\n") -18243 (flush *(ebp+0x10)) -18244 (stop *(ebp+0x14) 1) -18245 # never gets here -18246 -18247 $populate-mu-type:error2: -18248 (write-buffered *(ebp+0x10) "type ") -18249 (type-name *edi) # Typeinfo-id => eax -18250 (write-buffered *(ebp+0x10) %eax) -18251 (write-buffered *(ebp+0x10) ": 'addr' elements not allowed\n") -18252 (flush *(ebp+0x10)) -18253 (stop *(ebp+0x14) 1) -18254 # never gets here +18065 test-parse-mu-stmt: +18066 # . prologue +18067 55/push-ebp +18068 89/<- %ebp 4/r32/esp +18069 # setup +18070 8b/-> *Primitive-type-ids 0/r32/eax +18071 89/<- *Type-id 0/r32/eax # stream-write +18072 (clear-stream _test-input-stream) +18073 (write _test-input-stream "increment n\n") +18074 # var vars/ecx: (stack (addr var) 16) +18075 81 5/subop/subtract %esp 0xc0/imm32 +18076 68/push 0xc0/imm32/size +18077 68/push 0/imm32/top +18078 89/<- %ecx 4/r32/esp +18079 (clear-stack %ecx) +18080 # var v/edx: (handle var) +18081 68/push 0/imm32 +18082 68/push 0/imm32 +18083 89/<- %edx 4/r32/esp +18084 # var s/eax: (handle array byte) +18085 68/push 0/imm32 +18086 68/push 0/imm32 +18087 89/<- %eax 4/r32/esp +18088 # v = new var("n") +18089 (copy-array Heap "n" %eax) +18090 (new-var Heap *eax *(eax+4) %edx) +18091 # +18092 (push %ecx *edx) +18093 (push %ecx *(edx+4)) +18094 (push %ecx 0) +18095 # var out/eax: (handle stmt) +18096 68/push 0/imm32 +18097 68/push 0/imm32 +18098 89/<- %eax 4/r32/esp +18099 # convert +18100 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0) +18101 # var out-addr/edx: (addr stmt) = lookup(*out) +18102 (lookup *eax *(eax+4)) # => eax +18103 89/<- %edx 0/r32/eax +18104 # out->tag +18105 (check-ints-equal *edx 1 "F - test-parse-mu-stmt/tag") # Stmt-tag is Stmt1 +18106 # out->operation +18107 (lookup *(edx+4) *(edx+8)) # Stmt1-operation Stmt1-operation => eax +18108 (check-strings-equal %eax "increment" "F - test-parse-mu-stmt/name") # Stmt1-operation +18109 # out->inouts->value->name +18110 # . eax = out->inouts +18111 (lookup *(edx+0xc) *(edx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +18112 # . eax = out->inouts->value +18113 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +18114 # . eax = out->inouts->value->name +18115 (lookup *eax *(eax+4)) # Var-name Var-name => eax +18116 # . +18117 (check-strings-equal %eax "n" "F - test-parse-mu-stmt/inout:0") +18118 # . epilogue +18119 89/<- %esp 5/r32/ebp +18120 5d/pop-to-ebp +18121 c3/return +18122 +18123 test-parse-mu-stmt-with-comma: +18124 # . prologue +18125 55/push-ebp +18126 89/<- %ebp 4/r32/esp +18127 # setup +18128 8b/-> *Primitive-type-ids 0/r32/eax +18129 89/<- *Type-id 0/r32/eax # stream-write +18130 (clear-stream _test-input-stream) +18131 (write _test-input-stream "copy-to n, 3\n") +18132 # var vars/ecx: (stack (addr var) 16) +18133 81 5/subop/subtract %esp 0xc0/imm32 +18134 68/push 0xc0/imm32/size +18135 68/push 0/imm32/top +18136 89/<- %ecx 4/r32/esp +18137 (clear-stack %ecx) +18138 # var v/edx: (handle var) +18139 68/push 0/imm32 +18140 68/push 0/imm32 +18141 89/<- %edx 4/r32/esp +18142 # var s/eax: (handle array byte) +18143 68/push 0/imm32 +18144 68/push 0/imm32 +18145 89/<- %eax 4/r32/esp +18146 # v = new var("n") +18147 (copy-array Heap "n" %eax) +18148 (new-var Heap *eax *(eax+4) %edx) +18149 # +18150 (push %ecx *edx) +18151 (push %ecx *(edx+4)) +18152 (push %ecx 0) +18153 # var out/eax: (handle stmt) +18154 68/push 0/imm32 +18155 68/push 0/imm32 +18156 89/<- %eax 4/r32/esp +18157 # convert +18158 (parse-mu-stmt _test-input-stream %ecx 0 %eax Stderr 0) +18159 # var out-addr/edx: (addr stmt) = lookup(*out) +18160 (lookup *eax *(eax+4)) # => eax +18161 89/<- %edx 0/r32/eax +18162 # out->tag +18163 (check-ints-equal *edx 1 "F - test-parse-mu-stmt-with-comma/tag") # Stmt-tag is Stmt1 +18164 # out->operation +18165 (lookup *(edx+4) *(edx+8)) # Stmt1-operation Stmt1-operation => eax +18166 (check-strings-equal %eax "copy-to" "F - test-parse-mu-stmt-with-comma/name") # Stmt1-operation +18167 # out->inouts->value->name +18168 # . eax = out->inouts +18169 (lookup *(edx+0xc) *(edx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +18170 # . eax = out->inouts->value +18171 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +18172 # . eax = out->inouts->value->name +18173 (lookup *eax *(eax+4)) # Var-name Var-name => eax +18174 # . +18175 (check-strings-equal %eax "n" "F - test-parse-mu-stmt-with-comma/inout:0") +18176 # . epilogue +18177 89/<- %esp 5/r32/ebp +18178 5d/pop-to-ebp +18179 c3/return +18180 +18181 new-var: # ad: (addr allocation-descriptor), name: (handle array byte), out: (addr handle var) +18182 # . prologue +18183 55/push-ebp +18184 89/<- %ebp 4/r32/esp +18185 # . save registers +18186 50/push-eax +18187 51/push-ecx +18188 # ecx = out +18189 8b/-> *(ebp+0x14) 1/r32/ecx +18190 # +18191 (allocate *(ebp+8) *Var-size %ecx) +18192 # var out-addr/eax: (addr var) +18193 (lookup *ecx *(ecx+4)) # => eax +18194 # out-addr->name = name +18195 8b/-> *(ebp+0xc) 1/r32/ecx +18196 89/<- *eax 1/r32/ecx # Var-name +18197 8b/-> *(ebp+0x10) 1/r32/ecx +18198 89/<- *(eax+4) 1/r32/ecx # Var-name +18199 #? (write-buffered Stderr "var ") +18200 #? (lookup *(ebp+0xc) *(ebp+0x10)) +18201 #? (write-buffered Stderr %eax) +18202 #? (write-buffered Stderr " at ") +18203 #? 8b/-> *(ebp+0x14) 1/r32/ecx +18204 #? (lookup *ecx *(ecx+4)) # => eax +18205 #? (write-int32-hex-buffered Stderr %eax) +18206 #? (write-buffered Stderr Newline) +18207 #? (flush Stderr) +18208 $new-var:end: +18209 # . restore registers +18210 59/pop-to-ecx +18211 58/pop-to-eax +18212 # . epilogue +18213 89/<- %esp 5/r32/ebp +18214 5d/pop-to-ebp +18215 c3/return +18216 +18217 new-literal-integer: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +18218 # . prologue +18219 55/push-ebp +18220 89/<- %ebp 4/r32/esp +18221 # . save registers +18222 50/push-eax +18223 51/push-ecx +18224 # if (!is-hex-int?(name)) abort +18225 (is-hex-int? *(ebp+0xc)) # => eax +18226 3d/compare-eax-and 0/imm32/false +18227 0f 84/jump-if-= $new-literal-integer:abort/disp32 +18228 # a little more error-checking +18229 (check-mu-hex-int *(ebp+0xc) *(ebp+0x18) *(ebp+0x1c)) +18230 # out = new var(s) +18231 (new-var-from-slice *(ebp+8) *(ebp+0xc) *(ebp+0x10)) +18232 # var out-addr/ecx: (addr var) = lookup(*out) +18233 8b/-> *(ebp+0x10) 0/r32/eax +18234 (lookup *eax *(eax+4)) # => eax +18235 89/<- %ecx 0/r32/eax +18236 # out-addr->block-depth = *Curr-block-depth +18237 8b/-> *Curr-block-depth 0/r32/eax +18238 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth +18239 # out-addr->type = new tree() +18240 8d/copy-address *(ecx+8) 0/r32/eax # Var-type +18241 (allocate *(ebp+8) *Type-tree-size %eax) +18242 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +18243 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom +18244 # nothing else to do; default type is 'literal' +18245 $new-literal-integer:end: +18246 # . reclaim locals +18247 81 0/subop/add %esp 8/imm32 +18248 # . restore registers +18249 59/pop-to-ecx +18250 58/pop-to-eax +18251 # . epilogue +18252 89/<- %esp 5/r32/ebp +18253 5d/pop-to-ebp +18254 c3/return 18255 -18256 $populate-mu-type:error3: -18257 (write-buffered *(ebp+0x10) "type ") -18258 (type-name *edi) # Typeinfo-id => eax -18259 (write-buffered *(ebp+0x10) %eax) -18260 (write-buffered *(ebp+0x10) ": 'array' elements not allowed for now\n") -18261 (flush *(ebp+0x10)) -18262 (stop *(ebp+0x14) 1) -18263 # never gets here -18264 -18265 $populate-mu-type:error4: -18266 (write-buffered *(ebp+0x10) "type ") -18267 (type-name *edi) # Typeinfo-id => eax -18268 (write-buffered *(ebp+0x10) %eax) -18269 (write-buffered *(ebp+0x10) ": 'byte' elements not allowed\n") -18270 (flush *(ebp+0x10)) -18271 (stop *(ebp+0x14) 1) -18272 # never gets here -18273 -18274 $populate-mu-type:error5: -18275 (write-buffered *(ebp+0x10) "type ") -18276 (type-name *edi) # Typeinfo-id => eax -18277 (write-buffered *(ebp+0x10) %eax) -18278 (write-buffered *(ebp+0x10) ": 'slice' elements not allowed\n") -18279 (flush *(ebp+0x10)) -18280 (stop *(ebp+0x14) 1) -18281 # never gets here -18282 -18283 $populate-mu-type:error6: -18284 (write-buffered *(ebp+0x10) "type ") -18285 (type-name *edi) # Typeinfo-id => eax -18286 (write-buffered *(ebp+0x10) %eax) -18287 (write-buffered *(ebp+0x10) ": 'stream' elements not allowed for now\n") -18288 (flush *(ebp+0x10)) -18289 (stop *(ebp+0x14) 1) -18290 # never gets here -18291 -18292 type-name: # index: int -> result/eax: (addr array byte) -18293 # . prologue -18294 55/push-ebp -18295 89/<- %ebp 4/r32/esp -18296 # -18297 (index Type-id *(ebp+8)) -18298 $type-name:end: -18299 # . epilogue -18300 89/<- %esp 5/r32/ebp -18301 5d/pop-to-ebp -18302 c3/return -18303 -18304 index: # arr: (addr stream (handle array byte)), index: int -> result/eax: (addr array byte) -18305 # . prologue -18306 55/push-ebp -18307 89/<- %ebp 4/r32/esp -18308 # . save registers -18309 56/push-esi -18310 # TODO: bounds-check index -18311 # esi = arr -18312 8b/-> *(ebp+8) 6/r32/esi -18313 # eax = index -18314 8b/-> *(ebp+0xc) 0/r32/eax -18315 # eax = *(arr + 12 + index) -18316 8b/-> *(esi+eax<<2+0xc) 0/r32/eax -18317 $index:end: +18256 $new-literal-integer:abort: +18257 (write-buffered *(ebp+0x18) "fn ") +18258 8b/-> *(ebp+0x14) 0/r32/eax +18259 (lookup *eax *(eax+4)) # Function-name Function-name => eax +18260 (write-buffered *(ebp+0x18) %eax) +18261 (write-buffered *(ebp+0x18) ": variable '") +18262 (write-slice-buffered *(ebp+0x18) *(ebp+0xc)) +18263 (write-buffered *(ebp+0x18) "' cannot begin with a digit (or do you have a typo in a number?)\n") +18264 (flush *(ebp+0x18)) +18265 (stop *(ebp+0x1c) 1) +18266 # never gets here +18267 +18268 # precondition: name is a valid hex integer; require a '0x' prefix +18269 check-mu-hex-int: # name: (addr slice), err: (addr buffered-file), ed: (addr exit-descriptor) +18270 # . prologue +18271 55/push-ebp +18272 89/<- %ebp 4/r32/esp +18273 # . save registers +18274 50/push-eax +18275 51/push-ecx +18276 52/push-edx +18277 # ecx = name +18278 8b/-> *(ebp+8) 1/r32/ecx +18279 # var start/edx: (addr byte) = name->start +18280 8b/-> *ecx 2/r32/edx +18281 # if (*start == '-') ++start +18282 b8/copy-to-eax 0/imm32 +18283 8a/copy-byte *edx 0/r32/AL +18284 3d/compare-eax-and 0x2d/imm32/dash +18285 { +18286 75/jump-if-!= break/disp8 +18287 42/increment-edx +18288 } +18289 # var end/ecx: (addr byte) = name->end +18290 8b/-> *(ecx+4) 1/r32/ecx +18291 # var len/eax: int = name->end - name->start +18292 89/<- %eax 1/r32/ecx +18293 29/subtract-from %eax 2/r32/edx +18294 # if (len <= 1) return +18295 3d/compare-eax-with 1/imm32 +18296 0f 8e/jump-if-<= $check-mu-hex-int:end/disp32 +18297 $check-mu-hex-int:length->-1: +18298 # if slice-starts-with?({start, end}, "0x") return +18299 # . var tmp = {start, end} +18300 51/push-ecx +18301 52/push-edx +18302 89/<- %eax 4/r32/esp +18303 # . +18304 (slice-starts-with? %eax "0x") # => eax +18305 # . reclaim tmp +18306 81 0/subop/add %esp 8/imm32 +18307 # . +18308 3d/compare-eax-with 0/imm32/false +18309 75/jump-if-!= $check-mu-hex-int:end/disp8 +18310 $check-mu-hex-int:abort: +18311 # otherwise abort +18312 (write-buffered *(ebp+0xc) "literal integers are always hex in Mu; start '") +18313 (write-slice-buffered *(ebp+0xc) *(ebp+8)) +18314 (write-buffered *(ebp+0xc) "' with a '0x' to be unambiguous, converting it to hexadecimal as necessary.\n") +18315 (flush *(ebp+0xc)) +18316 (stop *(ebp+0x10) 1) +18317 $check-mu-hex-int:end: 18318 # . restore registers -18319 5e/pop-to-esi -18320 # . epilogue -18321 89/<- %esp 5/r32/ebp -18322 5d/pop-to-ebp -18323 c3/return -18324 -18325 ####################################################### -18326 # Compute type sizes -18327 ####################################################### -18328 -18329 # Compute the sizes of all user-defined types. -18330 # We'll need the sizes of their elements, which may be other user-defined -18331 # types, which we will compute as needed. -18332 -18333 # Initially, all user-defined types have their sizes set to -2 (invalid) -18334 populate-mu-type-sizes: # err: (addr buffered-file), ed: (addr exit-descriptor) -18335 # . prologue -18336 55/push-ebp -18337 89/<- %ebp 4/r32/esp -18338 $populate-mu-type-sizes:total-sizes: -18339 # var curr/eax: (addr typeinfo) = lookup(Program->types) -18340 (lookup *_Program-types *_Program-types->payload) # => eax -18341 { -18342 # if (curr == null) break -18343 3d/compare-eax-and 0/imm32/null -18344 74/jump-if-= break/disp8 -18345 (populate-mu-type-sizes-in-type %eax *(ebp+8) *(ebp+0xc)) -18346 # curr = lookup(curr->next) -18347 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax -18348 eb/jump loop/disp8 -18349 } -18350 $populate-mu-type-sizes:offsets: -18351 # curr = *Program->types -18352 (lookup *_Program-types *_Program-types->payload) # => eax -18353 { -18354 # if (curr == null) break -18355 3d/compare-eax-and 0/imm32/null -18356 74/jump-if-= break/disp8 -18357 (populate-mu-type-offsets %eax *(ebp+8) *(ebp+0xc)) -18358 # curr = curr->next -18359 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax -18360 eb/jump loop/disp8 -18361 } -18362 $populate-mu-type-sizes:end: -18363 # . epilogue -18364 89/<- %esp 5/r32/ebp -18365 5d/pop-to-ebp -18366 c3/return -18367 -18368 # compute sizes of all fields, recursing as necessary -18369 # sum up all their sizes to arrive at total size -18370 # fields may be out of order, but that doesn't affect the answer -18371 populate-mu-type-sizes-in-type: # T: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) -18372 # . prologue -18373 55/push-ebp -18374 89/<- %ebp 4/r32/esp -18375 # . save registers -18376 50/push-eax -18377 51/push-ecx -18378 52/push-edx -18379 56/push-esi -18380 57/push-edi -18381 # esi = T -18382 8b/-> *(ebp+8) 6/r32/esi -18383 # if T is already computed, return -18384 81 7/subop/compare *(esi+0xc) 0/imm32 # Typeinfo-total-size-in-bytes -18385 0f 8d/jump-if->= $populate-mu-type-sizes-in-type:end/disp32 -18386 # if T is being computed, abort -18387 81 7/subop/compare *(esi+0xc) -1/imm32/being-computed # Typeinfo-total-size-in-bytes -18388 0f 84/jump-if-= $populate-mu-type-sizes-in-type:abort/disp32 -18389 # tag T (-2 to -1) to avoid infinite recursion -18390 c7 0/subop/copy *(esi+0xc) -1/imm32/being-computed # Typeinfo-total-size-in-bytes -18391 # var total-size/edi: int = 0 -18392 bf/copy-to-edi 0/imm32 -18393 # - for every field, if it's a user-defined type, compute its size -18394 # var table/ecx: (addr table (handle array byte) (handle typeinfo-entry)) = lookup(T->fields) -18395 (lookup *(esi+4) *(esi+8)) # Typeinfo-fields Typeinfo-fields => eax -18396 89/<- %ecx 0/r32/eax -18397 # var table-size/edx: int = table->write -18398 8b/-> *ecx 2/r32/edx # stream-write -18399 # var curr/ecx: (addr table_row) = table->data -18400 8d/copy-address *(ecx+0xc) 1/r32/ecx -18401 # var max/edx: (addr table_row) = table->data + table->write -18402 8d/copy-address *(ecx+edx) 2/r32/edx -18403 { -18404 $populate-mu-type-sizes-in-type:loop: -18405 # if (curr >= max) break -18406 39/compare %ecx 2/r32/edx -18407 73/jump-if-addr>= break/disp8 -18408 # var t/eax: (addr typeinfo-entry) = lookup(curr->value) -18409 (lookup *(ecx+8) *(ecx+0xc)) # => eax -18410 # if (t->input-var == 0) silently ignore it; we'll emit a nice error message while type-checking -18411 81 7/subop/compare *eax 0/imm32 # Typeinfo-entry-input-var -18412 74/jump-if-= $populate-mu-type-sizes-in-type:end/disp8 -18413 # compute size of t->input-var -18414 (lookup *eax *(eax+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax -18415 (compute-size-of-var %eax *(ebp+0xc) *(ebp+0x10)) # => eax -18416 # result += eax -18417 01/add-to %edi 0/r32/eax -18418 # curr += row-size -18419 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-fields-row-size -18420 # -18421 eb/jump loop/disp8 -18422 } -18423 # - save result -18424 89/<- *(esi+0xc) 7/r32/edi # Typeinfo-total-size-in-bytes -18425 $populate-mu-type-sizes-in-type:end: -18426 # . restore registers -18427 5f/pop-to-edi -18428 5e/pop-to-esi -18429 5a/pop-to-edx -18430 59/pop-to-ecx -18431 58/pop-to-eax -18432 # . epilogue -18433 89/<- %esp 5/r32/ebp -18434 5d/pop-to-ebp -18435 c3/return -18436 -18437 $populate-mu-type-sizes-in-type:abort: -18438 (write-buffered *(ebp+0xc) "cycle in type definitions\n") -18439 (flush *(ebp+0xc)) -18440 (stop *(ebp+0x10) 1) -18441 # never gets here -18442 -18443 # Analogous to size-of, except we need to compute what size-of can just read -18444 # off the right data structures. -18445 compute-size-of-var: # in: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -18446 # . prologue -18447 55/push-ebp -18448 89/<- %ebp 4/r32/esp -18449 # . push registers -18450 51/push-ecx -18451 # var t/ecx: (addr type-tree) = lookup(v->type) -18452 8b/-> *(ebp+8) 1/r32/ecx -18453 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -18454 89/<- %ecx 0/r32/eax -18455 # if (t->is-atom == false) t = lookup(t->left) -18456 { -18457 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -18458 75/jump-if-!= break/disp8 -18459 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -18460 89/<- %ecx 0/r32/eax -18461 } -18462 # TODO: ensure t is an atom -18463 (compute-size-of-type-id *(ecx+4) *(ebp+0xc) *(ebp+0x10)) # Type-tree-value => eax -18464 $compute-size-of-var:end: -18465 # . restore registers -18466 59/pop-to-ecx -18467 # . epilogue -18468 89/<- %esp 5/r32/ebp -18469 5d/pop-to-ebp -18470 c3/return -18471 -18472 compute-size-of-type-id: # t: type-id, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -18473 # . prologue -18474 55/push-ebp -18475 89/<- %ebp 4/r32/esp -18476 # . save registers -18477 51/push-ecx -18478 # var out/ecx: (handle typeinfo) -18479 68/push 0/imm32 -18480 68/push 0/imm32 -18481 89/<- %ecx 4/r32/esp -18482 # eax = t -18483 8b/-> *(ebp+8) 0/r32/eax -18484 # if t is a literal, return 0 -18485 3d/compare-eax-and 0/imm32/literal -18486 0f 84/jump-if-= $compute-size-of-type-id:end/disp32 # eax changes type from type-id to int -18487 # if t is a byte, return 4 (because we don't really support non-multiples of 4) -18488 3d/compare-eax-and 8/imm32/byte -18489 { -18490 75/jump-if-!= break/disp8 -18491 b8/copy-to-eax 4/imm32 -18492 eb/jump $compute-size-of-type-id:end/disp8 -18493 } -18494 # if t is a handle, return 8 -18495 3d/compare-eax-and 4/imm32/handle -18496 { -18497 75/jump-if-!= break/disp8 -18498 b8/copy-to-eax 8/imm32 -18499 eb/jump $compute-size-of-type-id:end/disp8 # eax changes type from type-id to int -18500 } -18501 # if t is a slice, return 8 -18502 3d/compare-eax-and 0xc/imm32/slice -18503 { -18504 75/jump-if-!= break/disp8 -18505 b8/copy-to-eax 8/imm32 -18506 eb/jump $compute-size-of-type-id:end/disp8 # eax changes type from type-id to int -18507 } -18508 # if t is a user-defined type, compute its size -18509 # TODO: support non-atom type -18510 (find-typeinfo %eax %ecx) -18511 { -18512 81 7/subop/compare *ecx 0/imm32 -18513 74/jump-if-= break/disp8 -18514 $compute-size-of-type-id:user-defined: -18515 (lookup *ecx *(ecx+4)) # => eax -18516 (populate-mu-type-sizes-in-type %eax *(ebp+0xc) *(ebp+0x10)) -18517 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes -18518 eb/jump $compute-size-of-type-id:end/disp8 +18319 5a/pop-to-edx +18320 59/pop-to-ecx +18321 58/pop-to-eax +18322 # . epilogue +18323 89/<- %esp 5/r32/ebp +18324 5d/pop-to-ebp +18325 c3/return +18326 +18327 new-literal: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) +18328 # . prologue +18329 55/push-ebp +18330 89/<- %ebp 4/r32/esp +18331 # . save registers +18332 50/push-eax +18333 51/push-ecx +18334 # var s/ecx: (handle array byte) +18335 68/push 0/imm32 +18336 68/push 0/imm32 +18337 89/<- %ecx 4/r32/esp +18338 # s = slice-to-string(name) +18339 (slice-to-string Heap *(ebp+0xc) %ecx) +18340 # allocate to out +18341 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) +18342 # var out-addr/ecx: (addr var) = lookup(*out) +18343 8b/-> *(ebp+0x10) 1/r32/ecx +18344 (lookup *ecx *(ecx+4)) # => eax +18345 89/<- %ecx 0/r32/eax +18346 # out-addr->block-depth = *Curr-block-depth +18347 8b/-> *Curr-block-depth 0/r32/eax +18348 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth +18349 # out-addr->type/eax = new type +18350 8d/copy-address *(ecx+8) 0/r32/eax # Var-type +18351 (allocate *(ebp+8) *Type-tree-size %eax) +18352 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +18353 # nothing else to do; default type is 'literal' +18354 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom +18355 $new-literal:end: +18356 # . reclaim locals +18357 81 0/subop/add %esp 8/imm32 +18358 # . restore registers +18359 59/pop-to-ecx +18360 58/pop-to-eax +18361 # . epilogue +18362 89/<- %esp 5/r32/ebp +18363 5d/pop-to-ebp +18364 c3/return +18365 +18366 new-literal-string: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) +18367 # . prologue +18368 55/push-ebp +18369 89/<- %ebp 4/r32/esp +18370 # . save registers +18371 50/push-eax +18372 51/push-ecx +18373 # var s/ecx: (handle array byte) +18374 68/push 0/imm32 +18375 68/push 0/imm32 +18376 89/<- %ecx 4/r32/esp +18377 # s = slice-to-string(name) +18378 (slice-to-string Heap *(ebp+0xc) %ecx) +18379 # allocate to out +18380 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) +18381 # var out-addr/ecx: (addr var) = lookup(*out) +18382 8b/-> *(ebp+0x10) 1/r32/ecx +18383 (lookup *ecx *(ecx+4)) # => eax +18384 89/<- %ecx 0/r32/eax +18385 # out-addr->block-depth = *Curr-block-depth +18386 8b/-> *Curr-block-depth 0/r32/eax +18387 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth +18388 # out-addr->type/eax = new type +18389 8d/copy-address *(ecx+8) 0/r32/eax # Var-type +18390 (allocate *(ebp+8) *Type-tree-size %eax) +18391 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +18392 # out-addr->type->value = literal-string +18393 c7 0/subop/copy *(eax+4) 0x10/imm32/type-id-string-literal # Type-tree-value +18394 # out-addr->type->is-atom? = true +18395 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom +18396 $new-literal-string:end: +18397 # . reclaim locals +18398 81 0/subop/add %esp 8/imm32 +18399 # . restore registers +18400 59/pop-to-ecx +18401 58/pop-to-eax +18402 # . epilogue +18403 89/<- %esp 5/r32/ebp +18404 5d/pop-to-ebp +18405 c3/return +18406 +18407 new-var-from-slice: # ad: (addr allocation-descriptor), name: (addr slice), out: (addr handle var) +18408 # . prologue +18409 55/push-ebp +18410 89/<- %ebp 4/r32/esp +18411 # . save registers +18412 51/push-ecx +18413 # var tmp/ecx: (handle array byte) +18414 68/push 0/imm32 +18415 68/push 0/imm32 +18416 89/<- %ecx 4/r32/esp +18417 # tmp = slice-to-string(name) +18418 (slice-to-string Heap *(ebp+0xc) %ecx) +18419 # out = new-var(tmp) +18420 (new-var *(ebp+8) *ecx *(ecx+4) *(ebp+0x10)) +18421 $new-var-from-slice:end: +18422 # . reclaim locals +18423 81 0/subop/add %esp 8/imm32 +18424 # . restore registers +18425 59/pop-to-ecx +18426 # . epilogue +18427 89/<- %esp 5/r32/ebp +18428 5d/pop-to-ebp +18429 c3/return +18430 +18431 new-var-def: # ad: (addr allocation-descriptor), var: (handle var), out: (addr handle stmt) +18432 # . prologue +18433 55/push-ebp +18434 89/<- %ebp 4/r32/esp +18435 # . save registers +18436 50/push-eax +18437 51/push-ecx +18438 # +18439 (allocate *(ebp+8) *Stmt-size *(ebp+0x14)) +18440 # var out-addr/eax: (addr stmt) = lookup(*out) +18441 8b/-> *(ebp+0x14) 0/r32/eax +18442 (lookup *eax *(eax+4)) # => eax +18443 # out-addr->tag = stmt +18444 c7 0/subop/copy *eax 2/imm32/tag/var-on-stack # Stmt-tag +18445 # result->var = var +18446 8b/-> *(ebp+0xc) 1/r32/ecx +18447 89/<- *(eax+4) 1/r32/ecx # Vardef-var +18448 8b/-> *(ebp+0x10) 1/r32/ecx +18449 89/<- *(eax+8) 1/r32/ecx # Vardef-var +18450 $new-var-def:end: +18451 # . restore registers +18452 59/pop-to-ecx +18453 58/pop-to-eax +18454 # . epilogue +18455 89/<- %esp 5/r32/ebp +18456 5d/pop-to-ebp +18457 c3/return +18458 +18459 new-reg-var-def: # ad: (addr allocation-descriptor), var: (handle var), out: (addr handle stmt) +18460 # . prologue +18461 55/push-ebp +18462 89/<- %ebp 4/r32/esp +18463 # . save registers +18464 50/push-eax +18465 # eax = out +18466 8b/-> *(ebp+0x14) 0/r32/eax +18467 # +18468 (allocate *(ebp+8) *Stmt-size %eax) +18469 # var out-addr/eax: (addr stmt) = lookup(*out) +18470 (lookup *eax *(eax+4)) # => eax +18471 # set tag +18472 c7 0/subop/copy *eax 3/imm32/tag/var-in-register # Stmt-tag +18473 # set output +18474 8d/copy-address *(eax+0x14) 0/r32/eax # Regvardef-outputs +18475 (append-stmt-var Heap *(ebp+0xc) *(ebp+0x10) 0 0 0 %eax) +18476 $new-reg-var-def:end: +18477 # . restore registers +18478 58/pop-to-eax +18479 # . epilogue +18480 89/<- %esp 5/r32/ebp +18481 5d/pop-to-ebp +18482 c3/return +18483 +18484 append-list: # ad: (addr allocation-descriptor), value: (handle _type), list: (handle list _type), out: (addr handle list _type) +18485 # . prologue +18486 55/push-ebp +18487 89/<- %ebp 4/r32/esp +18488 # . save registers +18489 50/push-eax +18490 51/push-ecx +18491 57/push-edi +18492 # edi = out +18493 8b/-> *(ebp+0x1c) 7/r32/edi +18494 # *out = new list +18495 (allocate *(ebp+8) *List-size %edi) +18496 # var out-addr/edi: (addr list _type) = lookup(*out) +18497 (lookup *edi *(edi+4)) # => eax +18498 89/<- %edi 0/r32/eax +18499 # out-addr->value = value +18500 8b/-> *(ebp+0xc) 0/r32/eax +18501 89/<- *edi 0/r32/eax # List-value +18502 8b/-> *(ebp+0x10) 0/r32/eax +18503 89/<- *(edi+4) 0/r32/eax # List-value +18504 # if (list == null) return +18505 81 7/subop/compare *(ebp+0x14) 0/imm32 +18506 74/jump-if-= $append-list:end/disp8 +18507 # otherwise append +18508 $append-list:non-empty-list: +18509 # var curr/eax: (addr list _type) = lookup(list) +18510 (lookup *(ebp+0x14) *(ebp+0x18)) # => eax +18511 # while (curr->next != null) curr = curr->next +18512 { +18513 81 7/subop/compare *(eax+8) 0/imm32 # List-next +18514 74/jump-if-= break/disp8 +18515 # curr = lookup(curr->next) +18516 (lookup *(eax+8) *(eax+0xc)) # List-next, List-next => eax +18517 # +18518 eb/jump loop/disp8 18519 } -18520 # otherwise return the word size -18521 b8/copy-to-eax 4/imm32 -18522 $compute-size-of-type-id:end: -18523 # . reclaim locals -18524 81 0/subop/add %esp 8/imm32 -18525 # . restore registers -18526 59/pop-to-ecx -18527 # . epilogue -18528 89/<- %esp 5/r32/ebp -18529 5d/pop-to-ebp -18530 c3/return -18531 -18532 # at this point we have total sizes for all user-defined types -18533 # compute offsets for each element -18534 # complication: fields may be out of order -18535 populate-mu-type-offsets: # in: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) -18536 # . prologue -18537 55/push-ebp -18538 89/<- %ebp 4/r32/esp -18539 # . save registers -18540 50/push-eax -18541 51/push-ecx -18542 52/push-edx -18543 53/push-ebx -18544 56/push-esi -18545 57/push-edi -18546 #? (dump-typeinfos "aaa\n") -18547 # var curr-offset/edi: int = 0 -18548 bf/copy-to-edi 0/imm32 -18549 # var table/ecx: (addr table string_key (handle typeinfo-entry)) = lookup(in->fields) -18550 8b/-> *(ebp+8) 1/r32/ecx -18551 (lookup *(ecx+4) *(ecx+8)) # Typeinfo-fields Typeinfo-fields => eax -18552 89/<- %ecx 0/r32/eax -18553 # var num-elems/edx: int = table->write / Typeinfo-fields-row-size -18554 8b/-> *ecx 2/r32/edx # stream-write -18555 c1 5/subop/shift-right-logical %edx 4/imm8 -18556 # var i/ebx: int = 0 -18557 bb/copy-to-ebx 0/imm32 -18558 { -18559 $populate-mu-type-offsets:loop: -18560 39/compare %ebx 2/r32/edx -18561 0f 8d/jump-if->= break/disp32 -18562 #? (write-buffered Stderr "looking up index ") -18563 #? (write-int32-hex-buffered Stderr %ebx) -18564 #? (write-buffered Stderr " in ") -18565 #? (write-int32-hex-buffered Stderr *(ebp+8)) -18566 #? (write-buffered Stderr Newline) -18567 #? (flush Stderr) -18568 # var v/esi: (addr typeinfo-entry) -18569 (locate-typeinfo-entry-with-index %ecx %ebx *(ebp+0xc) *(ebp+0x10)) # => eax -18570 89/<- %esi 0/r32/eax -18571 # if v is null, silently move on; we'll emit a nice error message while type-checking -18572 81 7/subop/compare %esi 0/imm32 # Typeinfo-entry-input-var -18573 74/jump-if-= $populate-mu-type-offsets:end/disp8 -18574 # if (v->input-var == 0) silently ignore v; we'll emit a nice error message while type-checking -18575 81 7/subop/compare *esi 0/imm32 # Typeinfo-entry-input-var -18576 74/jump-if-= $populate-mu-type-offsets:end/disp8 -18577 # v->output-var->offset = curr-offset -18578 # . eax: (addr var) -18579 (lookup *(esi+0xc) *(esi+0x10)) # Typeinfo-entry-output-var Typeinfo-entry-output-var => eax -18580 89/<- *(eax+0x14) 7/r32/edi # Var-offset -18581 # curr-offset += size-of(v->input-var) -18582 (lookup *esi *(esi+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax -18583 (size-of %eax) # => eax -18584 01/add-to %edi 0/r32/eax -18585 # ++i -18586 43/increment-ebx -18587 e9/jump loop/disp32 -18588 } -18589 $populate-mu-type-offsets:end: -18590 # . restore registers -18591 5f/pop-to-edi -18592 5e/pop-to-esi -18593 5b/pop-to-ebx -18594 5a/pop-to-edx -18595 59/pop-to-ecx -18596 58/pop-to-eax -18597 # . epilogue -18598 89/<- %esp 5/r32/ebp -18599 5d/pop-to-ebp -18600 c3/return -18601 -18602 locate-typeinfo-entry-with-index: # table: (addr table (handle array byte) (handle typeinfo-entry)), idx: int, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: (addr typeinfo-entry) -18603 # . prologue -18604 55/push-ebp -18605 89/<- %ebp 4/r32/esp -18606 # . save registers -18607 51/push-ecx -18608 52/push-edx -18609 53/push-ebx -18610 56/push-esi -18611 57/push-edi -18612 # esi = table -18613 8b/-> *(ebp+8) 6/r32/esi -18614 # var curr/ecx: (addr row (handle array byte) (handle typeinfo-entry)) = table->data -18615 8d/copy-address *(esi+0xc) 1/r32/ecx -18616 # var max/edx: (addr byte) = &table->data[table->write] -18617 8b/-> *esi 2/r32/edx -18618 8d/copy-address *(ecx+edx) 2/r32/edx -18619 { -18620 $locate-typeinfo-entry-with-index:loop: -18621 39/compare %ecx 2/r32/edx -18622 73/jump-if-addr>= break/disp8 -18623 # var v/eax: (addr typeinfo-entry) -18624 (lookup *(ecx+8) *(ecx+0xc)) # => eax -18625 # if (v->index == idx) return v -18626 8b/-> *(eax+8) 3/r32/ebx # Typeinfo-entry-index -18627 #? (write-buffered Stderr "comparing ") -18628 #? (write-int32-hex-buffered Stderr %ebx) -18629 #? (write-buffered Stderr " and ") -18630 #? (write-int32-hex-buffered Stderr *(ebp+0xc)) -18631 #? (write-buffered Stderr Newline) -18632 #? (flush Stderr) -18633 39/compare *(ebp+0xc) 3/r32/ebx -18634 74/jump-if-= $locate-typeinfo-entry-with-index:end/disp8 -18635 # curr += Typeinfo-entry-size -18636 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-entry-size -18637 # -18638 eb/jump loop/disp8 -18639 } -18640 # return 0 -18641 b8/copy-to-eax 0/imm32 -18642 $locate-typeinfo-entry-with-index:end: -18643 #? (write-buffered Stderr "returning ") -18644 #? (write-int32-hex-buffered Stderr %eax) -18645 #? (write-buffered Stderr Newline) -18646 #? (flush Stderr) -18647 # . restore registers -18648 5f/pop-to-edi -18649 5e/pop-to-esi -18650 5b/pop-to-ebx -18651 5a/pop-to-edx -18652 59/pop-to-ecx -18653 # . epilogue -18654 89/<- %esp 5/r32/ebp -18655 5d/pop-to-ebp -18656 c3/return -18657 -18658 dump-typeinfos: # hdr: (addr array byte) -18659 # . prologue -18660 55/push-ebp -18661 89/<- %ebp 4/r32/esp -18662 # . save registers -18663 50/push-eax -18664 # -18665 (write-buffered Stderr *(ebp+8)) -18666 (flush Stderr) -18667 # var curr/eax: (addr typeinfo) = lookup(Program->types) -18668 (lookup *_Program-types *_Program-types->payload) # => eax -18669 { -18670 # if (curr == null) break -18671 3d/compare-eax-and 0/imm32 -18672 74/jump-if-= break/disp8 -18673 (write-buffered Stderr "---\n") -18674 (flush Stderr) -18675 (dump-typeinfo %eax) -18676 # curr = lookup(curr->next) -18677 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax -18678 eb/jump loop/disp8 -18679 } -18680 $dump-typeinfos:end: -18681 # . restore registers -18682 58/pop-to-eax -18683 # . epilogue -18684 89/<- %esp 5/r32/ebp -18685 5d/pop-to-ebp -18686 c3/return -18687 -18688 dump-typeinfo: # in: (addr typeinfo) -18689 # . prologue -18690 55/push-ebp -18691 89/<- %ebp 4/r32/esp -18692 # . save registers -18693 50/push-eax -18694 51/push-ecx -18695 52/push-edx -18696 53/push-ebx -18697 56/push-esi -18698 57/push-edi -18699 # esi = in -18700 8b/-> *(ebp+8) 6/r32/esi -18701 # var table/ecx: (addr table (handle array byte) (handle typeinfo-entry)) = lookup(T->fields) -18702 (lookup *(esi+4) *(esi+8)) # Typeinfo-fields Typeinfo-fields => eax -18703 89/<- %ecx 0/r32/eax -18704 (write-buffered Stderr "id:") -18705 (write-int32-hex-buffered Stderr *esi) -18706 (write-buffered Stderr "\n") -18707 (write-buffered Stderr "fields @ ") -18708 (write-int32-hex-buffered Stderr %ecx) -18709 (write-buffered Stderr Newline) -18710 (flush Stderr) -18711 (write-buffered Stderr " write: ") -18712 (write-int32-hex-buffered Stderr *ecx) -18713 (write-buffered Stderr Newline) -18714 (flush Stderr) -18715 (write-buffered Stderr " read: ") -18716 (write-int32-hex-buffered Stderr *(ecx+4)) -18717 (write-buffered Stderr Newline) -18718 (flush Stderr) -18719 (write-buffered Stderr " size: ") -18720 (write-int32-hex-buffered Stderr *(ecx+8)) -18721 (write-buffered Stderr Newline) -18722 (flush Stderr) -18723 # var table-size/edx: int = table->write -18724 8b/-> *ecx 2/r32/edx # stream-write -18725 # var curr/ecx: (addr table_row) = table->data -18726 8d/copy-address *(ecx+0xc) 1/r32/ecx -18727 # var max/edx: (addr table_row) = table->data + table->write -18728 8d/copy-address *(ecx+edx) 2/r32/edx -18729 { -18730 $dump-typeinfo:loop: -18731 # if (curr >= max) break -18732 39/compare %ecx 2/r32/edx -18733 0f 83/jump-if-addr>= break/disp32 -18734 (write-buffered Stderr " row:\n") -18735 (write-buffered Stderr " key: ") -18736 (write-int32-hex-buffered Stderr *ecx) -18737 (write-buffered Stderr ",") -18738 (write-int32-hex-buffered Stderr *(ecx+4)) -18739 (write-buffered Stderr " = '") -18740 (lookup *ecx *(ecx+4)) -18741 (write-buffered Stderr %eax) -18742 (write-buffered Stderr "' @ ") -18743 (write-int32-hex-buffered Stderr %eax) -18744 (write-buffered Stderr Newline) -18745 (flush Stderr) -18746 (write-buffered Stderr " value: ") -18747 (write-int32-hex-buffered Stderr *(ecx+8)) -18748 (write-buffered Stderr ",") -18749 (write-int32-hex-buffered Stderr *(ecx+0xc)) -18750 (write-buffered Stderr " = typeinfo-entry@") -18751 (lookup *(ecx+8) *(ecx+0xc)) -18752 (write-int32-hex-buffered Stderr %eax) -18753 (write-buffered Stderr Newline) -18754 (flush Stderr) -18755 (write-buffered Stderr " input var@") -18756 (dump-var 5 %eax) -18757 (lookup *(ecx+8) *(ecx+0xc)) -18758 (write-buffered Stderr " index: ") -18759 (write-int32-hex-buffered Stderr *(eax+8)) -18760 (write-buffered Stderr Newline) -18761 (flush Stderr) -18762 (write-buffered Stderr " output var@") -18763 8d/copy-address *(eax+0xc) 0/r32/eax # Typeinfo-entry-output-var -18764 (dump-var 5 %eax) -18765 (flush Stderr) -18766 # curr += row-size -18767 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-fields-row-size -18768 # -18769 e9/jump loop/disp32 -18770 } -18771 $dump-typeinfo:end: +18520 # edi = out +18521 8b/-> *(ebp+0x1c) 7/r32/edi +18522 # curr->next = out +18523 8b/-> *edi 1/r32/ecx +18524 89/<- *(eax+8) 1/r32/ecx # List-next +18525 8b/-> *(edi+4) 1/r32/ecx +18526 89/<- *(eax+0xc) 1/r32/ecx # List-next +18527 # out = list +18528 8b/-> *(ebp+0x14) 1/r32/ecx +18529 89/<- *edi 1/r32/ecx +18530 8b/-> *(ebp+0x18) 1/r32/ecx +18531 89/<- *(edi+4) 1/r32/ecx +18532 $append-list:end: +18533 # . restore registers +18534 5f/pop-to-edi +18535 59/pop-to-ecx +18536 58/pop-to-eax +18537 # . epilogue +18538 89/<- %esp 5/r32/ebp +18539 5d/pop-to-ebp +18540 c3/return +18541 +18542 append-stmt-var: # ad: (addr allocation-descriptor), v: (handle var), vars: (handle stmt-var), is-deref?: boolean, out: (addr handle stmt-var) +18543 # . prologue +18544 55/push-ebp +18545 89/<- %ebp 4/r32/esp +18546 # . save registers +18547 50/push-eax +18548 51/push-ecx +18549 57/push-edi +18550 # edi = out +18551 8b/-> *(ebp+0x20) 7/r32/edi +18552 # out = new stmt-var +18553 (allocate *(ebp+8) *Stmt-var-size %edi) +18554 # var out-addr/ecx: (addr stmt-var) = lookup(*out) +18555 (lookup *edi *(edi+4)) # => eax +18556 89/<- %ecx 0/r32/eax +18557 # out-addr->value = v +18558 8b/-> *(ebp+0xc) 0/r32/eax +18559 89/<- *ecx 0/r32/eax # Stmt-var-value +18560 8b/-> *(ebp+0x10) 0/r32/eax +18561 89/<- *(ecx+4) 0/r32/eax # Stmt-var-value +18562 # out-addr->is-deref? = is-deref? +18563 8b/-> *(ebp+0x1c) 0/r32/eax +18564 89/<- *(ecx+0x10) 0/r32/eax # Stmt-var-is-deref +18565 # if (vars == null) return result +18566 81 7/subop/compare *(ebp+0x14) 0/imm32/null +18567 74/jump-if-= $append-stmt-var:end/disp8 +18568 # otherwise append +18569 # var curr/eax: (addr stmt-var) = lookup(vars) +18570 (lookup *(ebp+0x14) *(ebp+0x18)) # => eax +18571 # while (curr->next != null) curr = curr->next +18572 { +18573 81 7/subop/compare *(eax+8) 0/imm32 # Stmt-var-next +18574 74/jump-if-= break/disp8 +18575 # curr = lookup(curr->next) +18576 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next, Stmt-var-next => eax +18577 # +18578 eb/jump loop/disp8 +18579 } +18580 # curr->next = out +18581 8b/-> *edi 1/r32/ecx +18582 89/<- *(eax+8) 1/r32/ecx # Stmt-var-next +18583 8b/-> *(edi+4) 1/r32/ecx +18584 89/<- *(eax+0xc) 1/r32/ecx # Stmt-var-next +18585 # out = vars +18586 8b/-> *(ebp+0x14) 1/r32/ecx +18587 89/<- *edi 1/r32/ecx +18588 8b/-> *(ebp+0x18) 1/r32/ecx +18589 89/<- *(edi+4) 1/r32/ecx +18590 $append-stmt-var:end: +18591 # . restore registers +18592 5f/pop-to-edi +18593 59/pop-to-ecx +18594 58/pop-to-eax +18595 # . epilogue +18596 89/<- %esp 5/r32/ebp +18597 5d/pop-to-ebp +18598 c3/return +18599 +18600 append-to-block: # ad: (addr allocation-descriptor), block: (addr block), x: (handle stmt) +18601 # . prologue +18602 55/push-ebp +18603 89/<- %ebp 4/r32/esp +18604 # . save registers +18605 50/push-eax +18606 56/push-esi +18607 # esi = block +18608 8b/-> *(ebp+0xc) 6/r32/esi +18609 # block->stmts = append(x, block->stmts) +18610 8d/copy-address *(esi+4) 0/r32/eax # Block-stmts +18611 (append-list *(ebp+8) *(ebp+0x10) *(ebp+0x14) *(esi+4) *(esi+8) %eax) # ad, x, x, Block-stmts, Block-stmts +18612 $append-to-block:end: +18613 # . restore registers +18614 5e/pop-to-esi +18615 58/pop-to-eax +18616 # . epilogue +18617 89/<- %esp 5/r32/ebp +18618 5d/pop-to-ebp +18619 c3/return +18620 +18621 ## Parsing types +18622 # We need to create metadata on user-defined types, and we need to use this +18623 # metadata as we parse instructions. +18624 # However, we also want to allow types to be used before their definitions. +18625 # This means we can't ever assume any type data structures exist. +18626 +18627 lookup-or-create-constant: # container: (addr stmt-var), field-name: (addr slice), out: (addr handle var) +18628 # . prologue +18629 55/push-ebp +18630 89/<- %ebp 4/r32/esp +18631 # . save registers +18632 50/push-eax +18633 56/push-esi +18634 # var container-type/esi: type-id +18635 (container-type *(ebp+8)) # => eax +18636 89/<- %esi 0/r32/eax +18637 # var tmp/eax: (handle typeinfo) = find-or-create-typeinfo(container-type) +18638 68/push 0/imm32 +18639 68/push 0/imm32 +18640 89/<- %eax 4/r32/esp +18641 (find-or-create-typeinfo %esi %eax) +18642 # var tmp-addr/eax: (addr typeinfo) = lookup(tmp) +18643 (lookup *eax *(eax+4)) # => eax +18644 # result = find-or-create-typeinfo-output-var(typeinfo, field-name) +18645 #? (write-buffered Stderr "constant: ") +18646 #? (write-slice-buffered Stderr *(ebp+0xc)) +18647 #? (write-buffered Stderr Newline) +18648 #? (flush Stderr) +18649 (find-or-create-typeinfo-output-var %eax *(ebp+0xc) *(ebp+0x10)) +18650 #? 8b/-> *(ebp+0x10) 0/r32/eax +18651 #? (write-buffered Stderr "@") +18652 #? (lookup *eax *(eax+4)) +18653 #? (write-int32-hex-buffered Stderr %eax) +18654 #? (lookup *eax *(eax+4)) +18655 #? (write-buffered Stderr %eax) +18656 #? (write-buffered Stderr Newline) +18657 #? (flush Stderr) +18658 #? (write-buffered Stderr "offset: ") +18659 #? 8b/-> *(eax+0x14) 0/r32/eax +18660 #? (write-int32-hex-buffered Stderr %eax) +18661 #? (write-buffered Stderr Newline) +18662 #? (flush Stderr) +18663 $lookup-or-create-constant:end: +18664 # . reclaim locals +18665 81 0/subop/add %esp 8/imm32 +18666 # . restore registers +18667 5e/pop-to-esi +18668 58/pop-to-eax +18669 # . epilogue +18670 89/<- %esp 5/r32/ebp +18671 5d/pop-to-ebp +18672 c3/return +18673 +18674 # if addr var: +18675 # container->var->type->right->left->value +18676 # otherwise +18677 # container->var->type->value +18678 container-type: # container: (addr stmt-var) -> result/eax: type-id +18679 # . prologue +18680 55/push-ebp +18681 89/<- %ebp 4/r32/esp +18682 # +18683 8b/-> *(ebp+8) 0/r32/eax +18684 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +18685 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +18686 { +18687 81 7/subop/compare *(eax+8) 0/imm32 # Type-tree-right +18688 74/jump-if-= break/disp8 +18689 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +18690 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +18691 } +18692 8b/-> *(eax+4) 0/r32/eax # Type-tree-value +18693 $container-type:end: +18694 # . epilogue +18695 89/<- %esp 5/r32/ebp +18696 5d/pop-to-ebp +18697 c3/return +18698 +18699 is-container?: # t: type-id -> result/eax: boolean +18700 # . prologue +18701 55/push-ebp +18702 89/<- %ebp 4/r32/esp +18703 # +18704 8b/-> *(ebp+8) 0/r32/eax +18705 c1/shift 4/subop/left %eax 2/imm8 +18706 3b/compare 0/r32/eax *Primitive-type-ids +18707 0f 9d/set-if->= %al +18708 81 4/subop/and %eax 0xff/imm32 +18709 $is-container?:end: +18710 # . epilogue +18711 89/<- %esp 5/r32/ebp +18712 5d/pop-to-ebp +18713 c3/return +18714 +18715 find-or-create-typeinfo: # t: type-id, out: (addr handle typeinfo) +18716 # . prologue +18717 55/push-ebp +18718 89/<- %ebp 4/r32/esp +18719 # . save registers +18720 50/push-eax +18721 51/push-ecx +18722 52/push-edx +18723 57/push-edi +18724 # edi = out +18725 8b/-> *(ebp+0xc) 7/r32/edi +18726 # var fields/ecx: (handle table (handle array byte) (handle typeinfo-entry)) +18727 68/push 0/imm32 +18728 68/push 0/imm32 +18729 89/<- %ecx 4/r32/esp +18730 # find-typeinfo(t, out) +18731 (find-typeinfo *(ebp+8) %edi) +18732 { +18733 # if (*out != 0) break +18734 81 7/subop/compare *edi 0/imm32 +18735 0f 85/jump-if-!= break/disp32 +18736 $find-or-create-typeinfo:create: +18737 # *out = allocate +18738 (allocate Heap *Typeinfo-size %edi) +18739 # var tmp/eax: (addr typeinfo) = lookup(*out) +18740 (lookup *edi *(edi+4)) # => eax +18741 #? (write-buffered Stderr "created typeinfo at ") +18742 #? (write-int32-hex-buffered Stderr %eax) +18743 #? (write-buffered Stderr " for type-id ") +18744 #? (write-int32-hex-buffered Stderr *(ebp+8)) +18745 #? (write-buffered Stderr Newline) +18746 #? (flush Stderr) +18747 # tmp->id = t +18748 8b/-> *(ebp+8) 2/r32/edx +18749 89/<- *eax 2/r32/edx # Typeinfo-id +18750 # tmp->fields = new table +18751 # . fields = new table +18752 (new-stream Heap 0x40 *Typeinfo-fields-row-size %ecx) +18753 # . tmp->fields = fields +18754 8b/-> *ecx 2/r32/edx +18755 89/<- *(eax+4) 2/r32/edx # Typeinfo-fields +18756 8b/-> *(ecx+4) 2/r32/edx +18757 89/<- *(eax+8) 2/r32/edx # Typeinfo-fields +18758 # tmp->next = Program->types +18759 8b/-> *_Program-types 1/r32/ecx +18760 89/<- *(eax+0x10) 1/r32/ecx # Typeinfo-next +18761 8b/-> *_Program-types->payload 1/r32/ecx +18762 89/<- *(eax+0x14) 1/r32/ecx # Typeinfo-next +18763 # Program->types = out +18764 8b/-> *edi 1/r32/ecx +18765 89/<- *_Program-types 1/r32/ecx +18766 8b/-> *(edi+4) 1/r32/ecx +18767 89/<- *_Program-types->payload 1/r32/ecx +18768 } +18769 $find-or-create-typeinfo:end: +18770 # . reclaim locals +18771 81 0/subop/add %esp 8/imm32 18772 # . restore registers 18773 5f/pop-to-edi -18774 5e/pop-to-esi -18775 5b/pop-to-ebx -18776 5a/pop-to-edx -18777 59/pop-to-ecx -18778 58/pop-to-eax -18779 # . epilogue -18780 89/<- %esp 5/r32/ebp -18781 5d/pop-to-ebp -18782 c3/return -18783 -18784 dump-var: # indent: int, v: (addr handle var) -18785 # . prologue -18786 55/push-ebp -18787 89/<- %ebp 4/r32/esp -18788 # . save registers -18789 50/push-eax -18790 53/push-ebx -18791 # eax = v -18792 8b/-> *(ebp+0xc) 0/r32/eax -18793 # -18794 (write-int32-hex-buffered Stderr *eax) -18795 (write-buffered Stderr ",") -18796 (write-int32-hex-buffered Stderr *(eax+4)) -18797 (write-buffered Stderr "->") -18798 (lookup *eax *(eax+4)) -18799 (write-int32-hex-buffered Stderr %eax) -18800 (write-buffered Stderr Newline) -18801 (flush Stderr) -18802 { -18803 3d/compare-eax-and 0/imm32 -18804 0f 84/jump-if-= break/disp32 -18805 (emit-indent Stderr *(ebp+8)) -18806 (write-buffered Stderr "name: ") -18807 89/<- %ebx 0/r32/eax -18808 (write-int32-hex-buffered Stderr *ebx) # Var-name -18809 (write-buffered Stderr ",") -18810 (write-int32-hex-buffered Stderr *(ebx+4)) # Var-name -18811 (write-buffered Stderr "->") -18812 (lookup *ebx *(ebx+4)) # Var-name -18813 (write-int32-hex-buffered Stderr %eax) -18814 { -18815 3d/compare-eax-and 0/imm32 -18816 74/jump-if-= break/disp8 -18817 (write-buffered Stderr Space) -18818 (write-buffered Stderr %eax) -18819 } -18820 (write-buffered Stderr Newline) -18821 (flush Stderr) -18822 (emit-indent Stderr *(ebp+8)) -18823 (write-buffered Stderr "block depth: ") -18824 (write-int32-hex-buffered Stderr *(ebx+0x10)) # Var-block-depth -18825 (write-buffered Stderr Newline) -18826 (flush Stderr) -18827 (emit-indent Stderr *(ebp+8)) -18828 (write-buffered Stderr "stack offset: ") -18829 (write-int32-hex-buffered Stderr *(ebx+0x14)) # Var-offset -18830 (write-buffered Stderr Newline) -18831 (flush Stderr) -18832 (emit-indent Stderr *(ebp+8)) -18833 (write-buffered Stderr "reg: ") -18834 (write-int32-hex-buffered Stderr *(ebx+0x18)) # Var-register -18835 (write-buffered Stderr ",") -18836 (write-int32-hex-buffered Stderr *(ebx+0x1c)) # Var-register -18837 (write-buffered Stderr "->") -18838 (flush Stderr) -18839 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register -18840 (write-int32-hex-buffered Stderr %eax) -18841 { -18842 3d/compare-eax-and 0/imm32 -18843 74/jump-if-= break/disp8 -18844 (write-buffered Stderr Space) -18845 (write-buffered Stderr %eax) -18846 } -18847 (write-buffered Stderr Newline) -18848 (flush Stderr) -18849 } -18850 $dump-var:end: -18851 # . restore registers -18852 5b/pop-to-ebx -18853 58/pop-to-eax -18854 # . epilogue -18855 89/<- %esp 5/r32/ebp -18856 5d/pop-to-ebp -18857 c3/return -18858 -18859 ####################################################### -18860 # Type-checking -18861 ####################################################### -18862 -18863 check-mu-types: # err: (addr buffered-file), ed: (addr exit-descriptor) -18864 # . prologue -18865 55/push-ebp -18866 89/<- %ebp 4/r32/esp -18867 # . save registers -18868 50/push-eax -18869 # var curr/eax: (addr function) = lookup(Program->functions) -18870 (lookup *_Program-functions *_Program-functions->payload) # => eax -18871 { -18872 $check-mu-types:loop: -18873 # if (curr == null) break -18874 3d/compare-eax-and 0/imm32 -18875 0f 84/jump-if-= break/disp32 -18876 +-- 8 lines: #? # dump curr->name --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -18884 (check-mu-function %eax *(ebp+8) *(ebp+0xc)) -18885 # curr = lookup(curr->next) -18886 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax -18887 e9/jump loop/disp32 -18888 } -18889 $check-mu-types:end: -18890 # . restore registers -18891 58/pop-to-eax -18892 # . epilogue -18893 89/<- %esp 5/r32/ebp -18894 5d/pop-to-ebp -18895 c3/return -18896 -18897 check-mu-function: # fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -18898 # . prologue -18899 55/push-ebp -18900 89/<- %ebp 4/r32/esp -18901 # . save registers -18902 50/push-eax -18903 56/push-esi -18904 # esi = f -18905 8b/-> *(ebp+8) 6/r32/esi -18906 # outputs -18907 (lookup *(esi+0x10) *(esi+0x14)) # Function-outputs Function-outputs => eax -18908 (check-all-unique-registers %eax %esi *(ebp+0xc) *(ebp+0x10)) -18909 # body -18910 (lookup *(esi+0x18) *(esi+0x1c)) # Function-body Function-body => eax -18911 (check-mu-block %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10)) -18912 # if function has no outputs, we're done -18913 81 7/subop/compare *(esi+0x10) 0/imm32 -18914 74/jump-if-= $check-mu-function:end/disp8 -18915 # some final checks on body -18916 (check-final-stmt-is-return %eax %esi *(ebp+0xc) *(ebp+0x10)) -18917 (check-no-breaks %eax %esi *(ebp+0xc) *(ebp+0x10)) -18918 $check-mu-function:end: -18919 # . restore registers -18920 5e/pop-to-esi -18921 58/pop-to-eax -18922 # . epilogue -18923 89/<- %esp 5/r32/ebp -18924 5d/pop-to-ebp -18925 c3/return -18926 -18927 check-mu-block: # block: (addr block), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -18928 # . prologue -18929 55/push-ebp -18930 89/<- %ebp 4/r32/esp -18931 # . save registers -18932 50/push-eax -18933 # eax = block -18934 8b/-> *(ebp+8) 0/r32/eax -18935 # var stmts/eax: (addr list stmt) = lookup(block->statements) -18936 (lookup *(eax+4) *(eax+8)) # Block-stmts Block-stmts => eax -18937 # -18938 { -18939 $check-mu-block:check-empty: -18940 3d/compare-eax-and 0/imm32 -18941 0f 84/jump-if-= break/disp32 -18942 # emit block->statements -18943 (check-mu-stmt-list %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -18944 } -18945 $check-mu-block:end: -18946 # . restore registers -18947 58/pop-to-eax -18948 # . epilogue -18949 89/<- %esp 5/r32/ebp -18950 5d/pop-to-ebp -18951 c3/return -18952 -18953 check-mu-stmt-list: # stmts: (addr list stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -18954 # . prologue -18955 55/push-ebp -18956 89/<- %ebp 4/r32/esp -18957 # . save registers -18958 50/push-eax -18959 56/push-esi -18960 # esi = stmts -18961 8b/-> *(ebp+8) 6/r32/esi -18962 { -18963 $check-mu-stmt-list:loop: -18964 81 7/subop/compare %esi 0/imm32 -18965 0f 84/jump-if-= break/disp32 -18966 # var curr-stmt/eax: (addr stmt) = lookup(stmts->value) -18967 (lookup *esi *(esi+4)) # List-value List-value => eax -18968 { -18969 $check-mu-stmt-list:check-for-block: -18970 81 7/subop/compare *eax 0/imm32/block # Stmt-tag -18971 75/jump-if-!= break/disp8 -18972 $check-mu-stmt-list:block: -18973 (check-mu-block %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -18974 eb/jump $check-mu-stmt-list:continue/disp8 -18975 } -18976 { -18977 $check-mu-stmt-list:check-for-stmt1: -18978 81 7/subop/compare *eax 1/imm32/stmt1 # Stmt-tag -18979 0f 85/jump-if-!= break/disp32 -18980 $check-mu-stmt-list:stmt1: -18981 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -18982 eb/jump $check-mu-stmt-list:continue/disp8 -18983 } -18984 { -18985 $check-mu-stmt-list:check-for-reg-var-def: -18986 81 7/subop/compare *eax 3/imm32/reg-var-def # Stmt-tag -18987 0f 85/jump-if-!= break/disp32 -18988 $check-mu-stmt-list:reg-var-def: -18989 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -18990 eb/jump $check-mu-stmt-list:continue/disp8 -18991 } -18992 $check-mu-stmt-list:continue: -18993 # TODO: raise an error on unrecognized Stmt-tag -18994 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax -18995 89/<- %esi 0/r32/eax -18996 e9/jump loop/disp32 -18997 } -18998 $check-mu-stmt-list:end: -18999 # . restore registers -19000 5e/pop-to-esi -19001 58/pop-to-eax -19002 # . epilogue -19003 89/<- %esp 5/r32/ebp -19004 5d/pop-to-ebp -19005 c3/return -19006 -19007 check-mu-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -19008 # . prologue -19009 55/push-ebp -19010 89/<- %ebp 4/r32/esp -19011 # . save registers -19012 50/push-eax -19013 # - if stmt's operation matches a primitive, check against it -19014 (has-primitive-name? *(ebp+8)) # => eax -19015 3d/compare-eax-and 0/imm32/false -19016 { -19017 74/jump-if-= break/disp8 -19018 (check-mu-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19019 e9/jump $check-mu-stmt:end/disp32 -19020 } -19021 # - otherwise find a function to check against -19022 # var f/eax: (addr function) = lookup(*Program->functions) -19023 (lookup *_Program-functions *_Program-functions->payload) # => eax -19024 (find-matching-function %eax *(ebp+8)) # => eax -19025 3d/compare-eax-and 0/imm32 -19026 { -19027 74/jump-if-= break/disp8 -19028 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19029 eb/jump $check-mu-stmt:end/disp8 -19030 } -19031 # var f/eax: (addr function) = lookup(*Program->signatures) -19032 (lookup *_Program-signatures *_Program-signatures->payload) # => eax -19033 (find-matching-function %eax *(ebp+8)) # => eax -19034 3d/compare-eax-and 0/imm32 -19035 { -19036 74/jump-if-= break/disp8 -19037 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19038 eb/jump $check-mu-stmt:end/disp8 -19039 } -19040 # - otherwise abort -19041 e9/jump $check-mu-stmt:unknown-call/disp32 -19042 $check-mu-stmt:end: -19043 # . restore registers -19044 58/pop-to-eax -19045 # . epilogue -19046 89/<- %esp 5/r32/ebp -19047 5d/pop-to-ebp -19048 c3/return -19049 -19050 $check-mu-stmt:unknown-call: -19051 (write-buffered *(ebp+0x10) "unknown function '") -19052 8b/-> *(ebp+8) 0/r32/eax -19053 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -19054 (write-buffered *(ebp+0x10) %eax) -19055 (write-buffered *(ebp+0x10) "'\n") -19056 (flush *(ebp+0x10)) -19057 (stop *(ebp+0x14) 1) -19058 # never gets here -19059 -19060 has-primitive-name?: # stmt: (addr stmt) -> result/eax: boolean -19061 # . prologue -19062 55/push-ebp -19063 89/<- %ebp 4/r32/esp -19064 # . save registers -19065 51/push-ecx -19066 56/push-esi -19067 # var name/esi: (addr array byte) = lookup(stmt->operation) -19068 8b/-> *(ebp+8) 6/r32/esi -19069 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax -19070 89/<- %esi 0/r32/eax -19071 # if (name == "return") return true -19072 (string-equal? %esi "return") # => eax -19073 3d/compare-eax-and 0/imm32/false -19074 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19075 # if (name == "get") return true -19076 (string-equal? %esi "get") # => eax -19077 3d/compare-eax-and 0/imm32/false -19078 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19079 # if (name == "index") return true -19080 (string-equal? %esi "index") # => eax -19081 3d/compare-eax-and 0/imm32/false -19082 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19083 # if (name == "length") return true -19084 (string-equal? %esi "length") # => eax -19085 3d/compare-eax-and 0/imm32/false -19086 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19087 # if (name == "compute-offset") return true -19088 (string-equal? %esi "compute-offset") # => eax -19089 3d/compare-eax-and 0/imm32/false -19090 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19091 # if (name == "copy-object") return true -19092 (string-equal? %esi "copy-object") # => eax -19093 3d/compare-eax-and 0/imm32/false -19094 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19095 # if (name == "allocate") return true -19096 (string-equal? %esi "allocate") # => eax -19097 3d/compare-eax-and 0/imm32/false -19098 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19099 # if (name == "populate") return true -19100 (string-equal? %esi "populate") # => eax -19101 3d/compare-eax-and 0/imm32/false -19102 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19103 # if (name == "populate-stream") return true -19104 (string-equal? %esi "populate-stream") # => eax -19105 3d/compare-eax-and 0/imm32/false -19106 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19107 # if (name == "read-from-stream") return true -19108 (string-equal? %esi "read-from-stream") # => eax -19109 3d/compare-eax-and 0/imm32/false -19110 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19111 # if (name == "write-to-stream") return true -19112 (string-equal? %esi "write-to-stream") # => eax -19113 3d/compare-eax-and 0/imm32/false -19114 0f 85/jump-if-!= $has-primitive-name?:end/disp32 -19115 # var curr/ecx: (addr primitive) = Primitives -19116 b9/copy-to-ecx Primitives/imm32 -19117 { -19118 $has-primitive-name?:loop: -19119 # if (curr == null) break -19120 81 7/subop/compare %ecx 0/imm32 -19121 74/jump-if-= break/disp8 -19122 # if (primitive->name == name) return true -19123 (lookup *ecx *(ecx+4)) # Primitive-name Primitive-name => eax -19124 #? (write-buffered Stderr %eax) -19125 #? (write-buffered Stderr Newline) -19126 #? (flush Stderr) -19127 (string-equal? %esi %eax) # => eax -19128 3d/compare-eax-and 0/imm32/false -19129 75/jump-if-!= $has-primitive-name?:end/disp8 -19130 $has-primitive-name?:next-primitive: -19131 # curr = curr->next -19132 (lookup *(ecx+0x3c) *(ecx+0x40)) # Primitive-next Primitive-next => eax -19133 89/<- %ecx 0/r32/eax -19134 # -19135 e9/jump loop/disp32 -19136 } -19137 # return null -19138 b8/copy-to-eax 0/imm32 -19139 $has-primitive-name?:end: -19140 # . restore registers -19141 5e/pop-to-esi -19142 59/pop-to-ecx -19143 # . epilogue -19144 89/<- %esp 5/r32/ebp -19145 5d/pop-to-ebp -19146 c3/return -19147 -19148 check-mu-primitive: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -19149 # . prologue -19150 55/push-ebp -19151 89/<- %ebp 4/r32/esp -19152 # . save registers -19153 50/push-eax -19154 51/push-ecx -19155 # var op/ecx: (addr array byte) = lookup(stmt->operation) -19156 8b/-> *(ebp+8) 0/r32/eax -19157 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -19158 89/<- %ecx 0/r32/eax -19159 # if (op == "copy") check-mu-copy-stmt -19160 { -19161 (string-equal? %ecx "copy") # => eax -19162 3d/compare-eax-and 0/imm32/false -19163 74/jump-if-= break/disp8 -19164 (check-mu-copy-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19165 e9/jump $check-mu-primitive:end/disp32 -19166 } -19167 # if (op == "copy-to") check-mu-copy-to-stmt -19168 { -19169 (string-equal? %ecx "copy-to") # => eax -19170 3d/compare-eax-and 0/imm32/false -19171 74/jump-if-= break/disp8 -19172 (check-mu-copy-to-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19173 e9/jump $check-mu-primitive:end/disp32 -19174 } -19175 # if (op == "compare") check-mu-compare-stmt -19176 { -19177 (string-equal? %ecx "compare") # => eax -19178 3d/compare-eax-and 0/imm32/false -19179 74/jump-if-= break/disp8 -19180 (check-mu-compare-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19181 e9/jump $check-mu-primitive:end/disp32 -19182 } -19183 # if (op == "address") check-mu-address-stmt -19184 { -19185 (string-equal? %ecx "address") # => eax -19186 3d/compare-eax-and 0/imm32/false -19187 74/jump-if-= break/disp8 -19188 (check-mu-address-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19189 e9/jump $check-mu-primitive:end/disp32 -19190 } -19191 # if (op == "return") check-mu-return-stmt -19192 { -19193 (string-equal? %ecx "return") # => eax -19194 3d/compare-eax-and 0/imm32/false -19195 74/jump-if-= break/disp8 -19196 (check-mu-return-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19197 e9/jump $check-mu-primitive:end/disp32 -19198 } -19199 # if (op == "get") check-mu-get-stmt -19200 { -19201 (string-equal? %ecx "get") # => eax -19202 3d/compare-eax-and 0/imm32/false -19203 74/jump-if-= break/disp8 -19204 (check-mu-get-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19205 e9/jump $check-mu-primitive:end/disp32 -19206 } -19207 # if (op == "index") check-mu-index-stmt -19208 { -19209 (string-equal? %ecx "index") # => eax -19210 3d/compare-eax-and 0/imm32/false -19211 74/jump-if-= break/disp8 -19212 (check-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19213 e9/jump $check-mu-primitive:end/disp32 -19214 } -19215 # if (op == "length") check-mu-length-stmt -19216 { -19217 (string-equal? %ecx "length") # => eax -19218 3d/compare-eax-and 0/imm32/false -19219 74/jump-if-= break/disp8 -19220 (check-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19221 e9/jump $check-mu-primitive:end/disp32 -19222 } -19223 # if (op == "compute-offset") check-mu-compute-offset-stmt -19224 { -19225 (string-equal? %ecx "compute-offset") # => eax -19226 3d/compare-eax-and 0/imm32/false -19227 74/jump-if-= break/disp8 -19228 (check-mu-compute-offset-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19229 e9/jump $check-mu-primitive:end/disp32 -19230 } -19231 # if (op == "copy-object") check-mu-copy-object-stmt -19232 { -19233 (string-equal? %ecx "copy-object") # => eax -19234 3d/compare-eax-and 0/imm32/false -19235 74/jump-if-= break/disp8 -19236 (check-mu-copy-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19237 e9/jump $check-mu-primitive:end/disp32 -19238 } -19239 # if (op == "allocate") check-mu-allocate-stmt -19240 { -19241 (string-equal? %ecx "allocate") # => eax -19242 3d/compare-eax-and 0/imm32/false -19243 74/jump-if-= break/disp8 -19244 (check-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19245 e9/jump $check-mu-primitive:end/disp32 +18774 5a/pop-to-edx +18775 59/pop-to-ecx +18776 58/pop-to-eax +18777 # . epilogue +18778 89/<- %esp 5/r32/ebp +18779 5d/pop-to-ebp +18780 c3/return +18781 +18782 find-typeinfo: # t: type-id, out: (addr handle typeinfo) +18783 # . prologue +18784 55/push-ebp +18785 89/<- %ebp 4/r32/esp +18786 # . save registers +18787 50/push-eax +18788 51/push-ecx +18789 52/push-edx +18790 57/push-edi +18791 # ecx = t +18792 8b/-> *(ebp+8) 1/r32/ecx +18793 # edi = out +18794 8b/-> *(ebp+0xc) 7/r32/edi +18795 # *out = Program->types +18796 8b/-> *_Program-types 0/r32/eax +18797 89/<- *edi 0/r32/eax +18798 8b/-> *_Program-types->payload 0/r32/eax +18799 89/<- *(edi+4) 0/r32/eax +18800 { +18801 $find-typeinfo:loop: +18802 # if (*out == 0) break +18803 81 7/subop/compare *edi 0/imm32 +18804 74/jump-if-= break/disp8 +18805 $find-typeinfo:check: +18806 # var tmp/eax: (addr typeinfo) = lookup(*out) +18807 (lookup *edi *(edi+4)) # => eax +18808 # if (tmp->id == t) break +18809 39/compare *eax 1/r32/ecx # Typeinfo-id +18810 74/jump-if-= break/disp8 +18811 $find-typeinfo:continue: +18812 # *out = tmp->next +18813 8b/-> *(eax+0x10) 2/r32/edx # Typeinfo-next +18814 89/<- *edi 2/r32/edx +18815 8b/-> *(eax+0x14) 2/r32/edx # Typeinfo-next +18816 89/<- *(edi+4) 2/r32/edx +18817 # +18818 eb/jump loop/disp8 +18819 } +18820 $find-typeinfo:end: +18821 # . restore registers +18822 5f/pop-to-edi +18823 5a/pop-to-edx +18824 59/pop-to-ecx +18825 58/pop-to-eax +18826 # . epilogue +18827 89/<- %esp 5/r32/ebp +18828 5d/pop-to-ebp +18829 c3/return +18830 +18831 find-or-create-typeinfo-output-var: # T: (addr typeinfo), f: (addr slice), out: (addr handle var) +18832 # . prologue +18833 55/push-ebp +18834 89/<- %ebp 4/r32/esp +18835 # . save registers +18836 50/push-eax +18837 52/push-edx +18838 57/push-edi +18839 # var dest/edi: (handle typeinfo-entry) +18840 68/push 0/imm32 +18841 68/push 0/imm32 +18842 89/<- %edi 4/r32/esp +18843 # find-or-create-typeinfo-fields(T, f, dest) +18844 (find-or-create-typeinfo-fields *(ebp+8) *(ebp+0xc) %edi) +18845 # var dest-addr/edi: (addr typeinfo-entry) = lookup(dest) +18846 (lookup *edi *(edi+4)) # => eax +18847 89/<- %edi 0/r32/eax +18848 # if dest-addr->output-var doesn't exist, create it +18849 { +18850 81 7/subop/compare *(edi+0xc) 0/imm32 # Typeinfo-entry-output-var +18851 0f 85/jump-if-!= break/disp32 +18852 # dest-addr->output-var = new var(dummy name, type, -1 offset) +18853 # . var name/eax: (handle array byte) = "field" +18854 68/push 0/imm32 +18855 68/push 0/imm32 +18856 89/<- %eax 4/r32/esp +18857 (slice-to-string Heap *(ebp+0xc) %eax) +18858 # . new var +18859 8d/copy-address *(edi+0xc) 2/r32/edx +18860 (new-var Heap *eax *(eax+4) %edx) +18861 # . reclaim name +18862 81 0/subop/add %esp 8/imm32 +18863 # var result/edx: (addr var) = lookup(dest-addr->output-var) +18864 (lookup *(edi+0xc) *(edi+0x10)) # => eax +18865 89/<- %edx 0/r32/eax +18866 # result->type = new constant type +18867 8d/copy-address *(edx+8) 0/r32/eax # Var-type +18868 (allocate Heap *Type-tree-size %eax) +18869 (lookup *(edx+8) *(edx+0xc)) # => eax +18870 c7 0/subop/copy *eax 1/imm32/true # Type-tree-is-atom +18871 c7 0/subop/copy *(eax+4) 6/imm32/constant # Type-tree-value +18872 c7 0/subop/copy *(eax+8) 0/imm32 # Type-tree-left +18873 c7 0/subop/copy *(eax+0xc) 0/imm32 # Type-tree-right +18874 c7 0/subop/copy *(eax+0x10) 0/imm32 # Type-tree-right +18875 # result->offset isn't filled out yet +18876 c7 0/subop/copy *(edx+0x14) -1/imm32/uninitialized # Var-offset +18877 } +18878 # out = dest-addr->output-var +18879 8b/-> *(ebp+0x10) 2/r32/edx +18880 8b/-> *(edi+0xc) 0/r32/eax # Typeinfo-entry-output-var +18881 89/<- *edx 0/r32/eax +18882 8b/-> *(edi+0x10) 0/r32/eax # Typeinfo-entry-output-var +18883 89/<- *(edx+4) 0/r32/eax +18884 $find-or-create-typeinfo-output-var:end: +18885 # . reclaim locals +18886 81 0/subop/add %esp 8/imm32 +18887 # . restore registers +18888 5f/pop-to-edi +18889 5a/pop-to-edx +18890 58/pop-to-eax +18891 # . epilogue +18892 89/<- %esp 5/r32/ebp +18893 5d/pop-to-ebp +18894 c3/return +18895 +18896 find-or-create-typeinfo-fields: # T: (addr typeinfo), f: (addr slice), out: (addr handle typeinfo-entry) +18897 # . prologue +18898 55/push-ebp +18899 89/<- %ebp 4/r32/esp +18900 # . save registers +18901 50/push-eax +18902 56/push-esi +18903 57/push-edi +18904 # eax = lookup(T->fields) +18905 8b/-> *(ebp+8) 0/r32/eax +18906 (lookup *(eax+4) *(eax+8)) # Typeinfo-fields Typeinfo-fields => eax +18907 # edi = out +18908 8b/-> *(ebp+0x10) 7/r32/edi +18909 # var src/esi: (addr handle typeinfo-entry) = get-or-insert-slice(T->fields, f) +18910 (get-or-insert-slice %eax *(ebp+0xc) *Typeinfo-fields-row-size Heap) # => eax +18911 89/<- %esi 0/r32/eax +18912 # if src doesn't exist, allocate it +18913 { +18914 81 7/subop/compare *esi 0/imm32 +18915 75/jump-if-!= break/disp8 +18916 (allocate Heap *Typeinfo-entry-size %esi) +18917 #? (write-buffered Stderr "handle at ") +18918 #? (write-int32-hex-buffered Stderr %esi) +18919 #? (write-buffered Stderr ": ") +18920 #? (write-int32-hex-buffered Stderr *esi) +18921 #? (write-buffered Stderr " ") +18922 #? (write-int32-hex-buffered Stderr *(esi+4)) +18923 #? (write-buffered Stderr Newline) +18924 #? (flush Stderr) +18925 #? (lookup *esi *(esi+4)) +18926 #? (write-buffered Stderr "created typeinfo fields at ") +18927 #? (write-int32-hex-buffered Stderr %esi) +18928 #? (write-buffered Stderr " for ") +18929 #? (write-int32-hex-buffered Stderr *(ebp+8)) +18930 #? (write-buffered Stderr Newline) +18931 #? (flush Stderr) +18932 } +18933 # *out = src +18934 # . *edi = *src +18935 8b/-> *esi 0/r32/eax +18936 89/<- *edi 0/r32/eax +18937 8b/-> *(esi+4) 0/r32/eax +18938 89/<- *(edi+4) 0/r32/eax +18939 $find-or-create-typeinfo-fields:end: +18940 # . restore registers +18941 5f/pop-to-edi +18942 5e/pop-to-esi +18943 58/pop-to-eax +18944 # . epilogue +18945 89/<- %esp 5/r32/ebp +18946 5d/pop-to-ebp +18947 c3/return +18948 +18949 populate-mu-type: # in: (addr stream byte), t: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) +18950 # pseudocode: +18951 # var line: (stream byte 512) +18952 # curr-index = 0 +18953 # while true +18954 # clear-stream(line) +18955 # read-line-buffered(in, line) +18956 # if line->write == 0 +18957 # abort +18958 # word-slice = next-mu-token(line) +18959 # if slice-empty?(word-slice) # end of line +18960 # continue +18961 # if slice-equal?(word-slice, "}") +18962 # break +18963 # var v: (handle var) = parse-var-with-type(word-slice, line) +18964 # var r: (handle typeinfo-fields) = find-or-create-typeinfo-fields(t, word-slice/v->name) +18965 # TODO: ensure that r->first is null +18966 # r->index = curr-index +18967 # curr-index++ +18968 # r->input-var = v +18969 # if r->output-var == 0 +18970 # r->output-var = new literal +18971 # TODO: ensure nothing else in line +18972 # t->total-size-in-bytes = -2 (not yet initialized) +18973 # +18974 # . prologue +18975 55/push-ebp +18976 89/<- %ebp 4/r32/esp +18977 # var curr-index: int at *(ebp-4) +18978 68/push 0/imm32 +18979 # . save registers +18980 50/push-eax +18981 51/push-ecx +18982 52/push-edx +18983 53/push-ebx +18984 56/push-esi +18985 57/push-edi +18986 # edi = t +18987 8b/-> *(ebp+0xc) 7/r32/edi +18988 # var line/ecx: (stream byte 512) +18989 81 5/subop/subtract %esp 0x200/imm32 +18990 68/push 0x200/imm32/size +18991 68/push 0/imm32/read +18992 68/push 0/imm32/write +18993 89/<- %ecx 4/r32/esp +18994 # var word-slice/edx: slice +18995 68/push 0/imm32/end +18996 68/push 0/imm32/start +18997 89/<- %edx 4/r32/esp +18998 # var v/esi: (handle var) +18999 68/push 0/imm32 +19000 68/push 0/imm32 +19001 89/<- %esi 4/r32/esp +19002 # var r/ebx: (handle typeinfo-entry) +19003 68/push 0/imm32 +19004 68/push 0/imm32 +19005 89/<- %ebx 4/r32/esp +19006 { +19007 $populate-mu-type:line-loop: +19008 (clear-stream %ecx) +19009 (read-line-buffered *(ebp+8) %ecx) +19010 # if (line->write == 0) abort +19011 81 7/subop/compare *ecx 0/imm32 +19012 0f 84/jump-if-= $populate-mu-type:error1/disp32 +19013 +-- 6 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +19019 (next-mu-token %ecx %edx) +19020 # if slice-empty?(word-slice) continue +19021 (slice-empty? %edx) # => eax +19022 3d/compare-eax-and 0/imm32 +19023 0f 85/jump-if-!= loop/disp32 +19024 # if slice-equal?(word-slice, "}") break +19025 (slice-equal? %edx "}") +19026 3d/compare-eax-and 0/imm32 +19027 0f 85/jump-if-!= break/disp32 +19028 $populate-mu-type:parse-element: +19029 # v = parse-var-with-type(word-slice, first-line) +19030 # must do this first to strip the trailing ':' from word-slice before +19031 # using it in find-or-create-typeinfo-fields below +19032 # TODO: clean up that mutation in parse-var-with-type +19033 (type-name *edi) # Typeinfo-id => eax +19034 (parse-var-with-type %edx %ecx %esi %eax *(ebp+0x10) *(ebp+0x14)) +19035 # if v is an addr, abort +19036 (lookup *esi *(esi+4)) # => eax +19037 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +19038 (is-mu-addr-type? %eax) # => eax +19039 3d/compare-eax-and 0/imm32/false +19040 0f 85/jump-if-!= $populate-mu-type:error2/disp32 +19041 # if v is an array, abort (we could support it, but initialization gets complex) +19042 (lookup *esi *(esi+4)) # => eax +19043 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +19044 (is-mu-array-type? %eax) # => eax +19045 3d/compare-eax-and 0/imm32/false +19046 0f 85/jump-if-!= $populate-mu-type:error3/disp32 +19047 # if v is a byte, abort +19048 (lookup *esi *(esi+4)) # => eax +19049 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +19050 (is-simple-mu-type? %eax 8) # byte => eax +19051 3d/compare-eax-and 0/imm32/false +19052 0f 85/jump-if-!= $populate-mu-type:error4/disp32 +19053 # if v is a slice, abort +19054 (lookup *esi *(esi+4)) # => eax +19055 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +19056 (is-simple-mu-type? %eax 0xc) # slice => eax +19057 3d/compare-eax-and 0/imm32/false +19058 0f 85/jump-if-!= $populate-mu-type:error5/disp32 +19059 # if v is a stream, abort (we could support it, but initialization gets even more complex) +19060 (lookup *esi *(esi+4)) # => eax +19061 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +19062 (is-mu-stream-type? %eax) # => eax +19063 3d/compare-eax-and 0/imm32/false +19064 0f 85/jump-if-!= $populate-mu-type:error6/disp32 +19065 # var tmp/ecx +19066 51/push-ecx +19067 $populate-mu-type:create-typeinfo-fields: +19068 # var r/ebx: (handle typeinfo-entry) +19069 (find-or-create-typeinfo-fields %edi %edx %ebx) +19070 # r->index = curr-index +19071 (lookup *ebx *(ebx+4)) # => eax +19072 8b/-> *(ebp-4) 1/r32/ecx +19073 #? (write-buffered Stderr "saving index ") +19074 #? (write-int32-hex-buffered Stderr %ecx) +19075 #? (write-buffered Stderr " at ") +19076 #? (write-int32-hex-buffered Stderr %edi) +19077 #? (write-buffered Stderr Newline) +19078 #? (flush Stderr) +19079 89/<- *(eax+8) 1/r32/ecx # Typeinfo-entry-index +19080 # ++curr-index +19081 ff 0/subop/increment *(ebp-4) +19082 $populate-mu-type:set-input-type: +19083 # r->input-var = v +19084 8b/-> *esi 1/r32/ecx +19085 89/<- *eax 1/r32/ecx # Typeinfo-entry-input-var +19086 8b/-> *(esi+4) 1/r32/ecx +19087 89/<- *(eax+4) 1/r32/ecx # Typeinfo-entry-input-var +19088 # restore line +19089 59/pop-to-ecx +19090 { +19091 $populate-mu-type:create-output-type: +19092 # if (r->output-var == 0) create a new var with some placeholder data +19093 81 7/subop/compare *(eax+0xc) 0/imm32 # Typeinfo-entry-output-var +19094 75/jump-if-!= break/disp8 +19095 8d/copy-address *(eax+0xc) 0/r32/eax # Typeinfo-entry-output-var +19096 (new-literal Heap %edx %eax) +19097 } +19098 e9/jump loop/disp32 +19099 } +19100 $populate-mu-type:invalidate-total-size-in-bytes: +19101 # Offsets and total size may not be accurate here since we may not yet +19102 # have encountered the element types. +19103 # We'll recompute them separately after parsing the entire program. +19104 c7 0/subop/copy *(edi+0xc) -2/imm32/uninitialized # Typeinfo-total-size-in-bytes +19105 $populate-mu-type:end: +19106 # . reclaim locals +19107 81 0/subop/add %esp 0x224/imm32 +19108 # . restore registers +19109 5f/pop-to-edi +19110 5e/pop-to-esi +19111 5b/pop-to-ebx +19112 5a/pop-to-edx +19113 59/pop-to-ecx +19114 58/pop-to-eax +19115 # reclaim curr-index +19116 81 0/subop/add %esp 4/imm32 +19117 # . epilogue +19118 89/<- %esp 5/r32/ebp +19119 5d/pop-to-ebp +19120 c3/return +19121 +19122 $populate-mu-type:error1: +19123 # error("incomplete type definition '" t->name "'\n") +19124 (write-buffered *(ebp+0x10) "incomplete type definition '") +19125 (type-name *edi) # Typeinfo-id => eax +19126 (write-buffered *(ebp+0x10) %eax) +19127 (write-buffered *(ebp+0x10) "\n") +19128 (flush *(ebp+0x10)) +19129 (stop *(ebp+0x14) 1) +19130 # never gets here +19131 +19132 $populate-mu-type:error2: +19133 (write-buffered *(ebp+0x10) "type ") +19134 (type-name *edi) # Typeinfo-id => eax +19135 (write-buffered *(ebp+0x10) %eax) +19136 (write-buffered *(ebp+0x10) ": 'addr' elements not allowed\n") +19137 (flush *(ebp+0x10)) +19138 (stop *(ebp+0x14) 1) +19139 # never gets here +19140 +19141 $populate-mu-type:error3: +19142 (write-buffered *(ebp+0x10) "type ") +19143 (type-name *edi) # Typeinfo-id => eax +19144 (write-buffered *(ebp+0x10) %eax) +19145 (write-buffered *(ebp+0x10) ": 'array' elements not allowed for now\n") +19146 (flush *(ebp+0x10)) +19147 (stop *(ebp+0x14) 1) +19148 # never gets here +19149 +19150 $populate-mu-type:error4: +19151 (write-buffered *(ebp+0x10) "type ") +19152 (type-name *edi) # Typeinfo-id => eax +19153 (write-buffered *(ebp+0x10) %eax) +19154 (write-buffered *(ebp+0x10) ": 'byte' elements not allowed\n") +19155 (flush *(ebp+0x10)) +19156 (stop *(ebp+0x14) 1) +19157 # never gets here +19158 +19159 $populate-mu-type:error5: +19160 (write-buffered *(ebp+0x10) "type ") +19161 (type-name *edi) # Typeinfo-id => eax +19162 (write-buffered *(ebp+0x10) %eax) +19163 (write-buffered *(ebp+0x10) ": 'slice' elements not allowed\n") +19164 (flush *(ebp+0x10)) +19165 (stop *(ebp+0x14) 1) +19166 # never gets here +19167 +19168 $populate-mu-type:error6: +19169 (write-buffered *(ebp+0x10) "type ") +19170 (type-name *edi) # Typeinfo-id => eax +19171 (write-buffered *(ebp+0x10) %eax) +19172 (write-buffered *(ebp+0x10) ": 'stream' elements not allowed for now\n") +19173 (flush *(ebp+0x10)) +19174 (stop *(ebp+0x14) 1) +19175 # never gets here +19176 +19177 type-name: # index: int -> result/eax: (addr array byte) +19178 # . prologue +19179 55/push-ebp +19180 89/<- %ebp 4/r32/esp +19181 # +19182 (index Type-id *(ebp+8)) +19183 $type-name:end: +19184 # . epilogue +19185 89/<- %esp 5/r32/ebp +19186 5d/pop-to-ebp +19187 c3/return +19188 +19189 index: # arr: (addr stream (handle array byte)), index: int -> result/eax: (addr array byte) +19190 # . prologue +19191 55/push-ebp +19192 89/<- %ebp 4/r32/esp +19193 # . save registers +19194 56/push-esi +19195 # TODO: bounds-check index +19196 # esi = arr +19197 8b/-> *(ebp+8) 6/r32/esi +19198 # eax = index +19199 8b/-> *(ebp+0xc) 0/r32/eax +19200 # eax = *(arr + 12 + index) +19201 8b/-> *(esi+eax<<2+0xc) 0/r32/eax +19202 $index:end: +19203 # . restore registers +19204 5e/pop-to-esi +19205 # . epilogue +19206 89/<- %esp 5/r32/ebp +19207 5d/pop-to-ebp +19208 c3/return +19209 +19210 ####################################################### +19211 # Compute type sizes +19212 ####################################################### +19213 +19214 # Compute the sizes of all user-defined types. +19215 # We'll need the sizes of their elements, which may be other user-defined +19216 # types, which we will compute as needed. +19217 +19218 # Initially, all user-defined types have their sizes set to -2 (invalid) +19219 populate-mu-type-sizes: # err: (addr buffered-file), ed: (addr exit-descriptor) +19220 # . prologue +19221 55/push-ebp +19222 89/<- %ebp 4/r32/esp +19223 $populate-mu-type-sizes:total-sizes: +19224 # var curr/eax: (addr typeinfo) = lookup(Program->types) +19225 (lookup *_Program-types *_Program-types->payload) # => eax +19226 { +19227 # if (curr == null) break +19228 3d/compare-eax-and 0/imm32/null +19229 74/jump-if-= break/disp8 +19230 (populate-mu-type-sizes-in-type %eax *(ebp+8) *(ebp+0xc)) +19231 # curr = lookup(curr->next) +19232 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax +19233 eb/jump loop/disp8 +19234 } +19235 $populate-mu-type-sizes:offsets: +19236 # curr = *Program->types +19237 (lookup *_Program-types *_Program-types->payload) # => eax +19238 { +19239 # if (curr == null) break +19240 3d/compare-eax-and 0/imm32/null +19241 74/jump-if-= break/disp8 +19242 (populate-mu-type-offsets %eax *(ebp+8) *(ebp+0xc)) +19243 # curr = curr->next +19244 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax +19245 eb/jump loop/disp8 19246 } -19247 # if (op == "populate") check-mu-populate-stmt -19248 { -19249 (string-equal? %ecx "populate") # => eax -19250 3d/compare-eax-and 0/imm32/false -19251 74/jump-if-= break/disp8 -19252 (check-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19253 e9/jump $check-mu-primitive:end/disp32 -19254 } -19255 # if (op == "populate-stream") check-mu-populate-stream-stmt -19256 { -19257 (string-equal? %ecx "populate-stream") # => eax -19258 3d/compare-eax-and 0/imm32/false -19259 74/jump-if-= break/disp8 -19260 (check-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19261 e9/jump $check-mu-primitive:end/disp32 -19262 } -19263 # if (op == "read-from-stream") check-mu-read-from-stream-stmt -19264 { -19265 (string-equal? %ecx "read-from-stream") # => eax -19266 3d/compare-eax-and 0/imm32/false -19267 74/jump-if-= break/disp8 -19268 (check-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19269 e9/jump $check-mu-primitive:end/disp32 -19270 } -19271 # if (op == "write-to-stream") check-mu-write-to-stream-stmt -19272 { -19273 (string-equal? %ecx "write-to-stream") # => eax -19274 3d/compare-eax-and 0/imm32/false -19275 74/jump-if-= break/disp8 -19276 (check-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19277 e9/jump $check-mu-primitive:end/disp32 -19278 } -19279 # if (op == "convert") check-mu-convert-stmt -19280 { -19281 (string-equal? %ecx "convert") # => eax -19282 3d/compare-eax-and 0/imm32/false -19283 74/jump-if-= break/disp8 -19284 (check-mu-convert-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19285 e9/jump $check-mu-primitive:end/disp32 -19286 } -19287 # otherwise check-numberlike-stmt -19288 (check-mu-numberlike-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19289 $check-mu-primitive:end: -19290 # . restore registers -19291 59/pop-to-ecx -19292 58/pop-to-eax -19293 # . epilogue -19294 89/<- %esp 5/r32/ebp -19295 5d/pop-to-ebp -19296 c3/return -19297 -19298 # by default, Mu primitives should only operate on 'number-like' types -19299 check-mu-numberlike-primitive: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -19300 # . prologue -19301 55/push-ebp -19302 89/<- %ebp 4/r32/esp -19303 # . save registers -19304 50/push-eax -19305 51/push-ecx -19306 56/push-esi -19307 # esi = stmt -19308 8b/-> *(ebp+8) 6/r32/esi -19309 # var gas/ecx: int = 2 -19310 b9/copy-to-ecx 2/imm32 -19311 # - check at most 1 output -19312 # var output/eax: (addr stmt-var) = stmt->outputs -19313 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -19314 { -19315 3d/compare-eax-and 0/imm32 -19316 74/jump-if-= break/disp8 -19317 $check-mu-numberlike-primitive:output: -19318 (check-mu-numberlike-output %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19319 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -19320 3d/compare-eax-and 0/imm32 -19321 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-outputs/disp32 -19322 # check output is in a register -19323 # --gas -19324 49/decrement-ecx -19325 } -19326 # - check first inout -19327 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -19328 { -19329 3d/compare-eax-and 0/imm32 -19330 0f 84/jump-if-= $check-mu-numberlike-primitive:end/disp32 -19331 $check-mu-numberlike-primitive:first-inout: -19332 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19333 # --gas -19334 49/decrement-ecx -19335 } -19336 # - check second inout -19337 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -19338 { -19339 3d/compare-eax-and 0/imm32 -19340 74/jump-if-= $check-mu-numberlike-primitive:end/disp8 -19341 $check-mu-numberlike-primitive:second-inout: -19342 # is a second inout allowed? -19343 81 7/subop/compare %ecx 0/imm32 -19344 0f 84/jump-if-= $check-mu-numberlike-primitive:error-too-many-inouts/disp32 -19345 $check-mu-numberlike-primitive:second-inout-permitted: -19346 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19347 } -19348 $check-mu-numberlike-primitive:third-inout: -19349 # if there's a third arg, raise an error -19350 81 7/subop/compare *(eax+8) 0/imm32 # Stmt-var-next -19351 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-inouts/disp32 -19352 $check-mu-numberlike-primitive:end: -19353 # . restore registers -19354 5e/pop-to-esi -19355 59/pop-to-ecx -19356 58/pop-to-eax -19357 # . epilogue -19358 89/<- %esp 5/r32/ebp -19359 5d/pop-to-ebp -19360 c3/return -19361 -19362 $check-mu-numberlike-primitive:error-too-many-inouts: -19363 (write-buffered *(ebp+0x10) "fn ") -19364 8b/-> *(ebp+0xc) 0/r32/eax -19365 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19366 (write-buffered *(ebp+0x10) %eax) -19367 (write-buffered *(ebp+0x10) ": stmt ") -19368 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax -19369 (write-buffered *(ebp+0x10) %eax) -19370 (write-buffered *(ebp+0x10) ": too many inouts; most primitives support at most two arguments, across inouts and outputs\n") -19371 (flush *(ebp+0x10)) -19372 (stop *(ebp+0x14) 1) -19373 # never gets here -19374 -19375 $check-mu-numberlike-primitive:error-too-many-outputs: -19376 (write-buffered *(ebp+0x10) "fn ") -19377 8b/-> *(ebp+0xc) 0/r32/eax -19378 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19379 (write-buffered *(ebp+0x10) %eax) -19380 (write-buffered *(ebp+0x10) ": stmt ") -19381 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax -19382 (write-buffered *(ebp+0x10) %eax) -19383 (write-buffered *(ebp+0x10) ": too many outputs; most primitives support at most one output\n") -19384 (flush *(ebp+0x10)) -19385 (stop *(ebp+0x14) 1) -19386 # never gets here -19387 -19388 check-mu-numberlike-arg: # v: (addr stmt-var), stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -19389 # . prologue -19390 55/push-ebp -19391 89/<- %ebp 4/r32/esp -19392 # . save registers -19393 50/push-eax -19394 56/push-esi -19395 # var t/esi: (addr type-tree) = lookup(v->value->type) -19396 8b/-> *(ebp+8) 0/r32/eax -19397 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -19398 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19399 89/<- %esi 0/r32/eax -19400 $check-mu-numberlike-arg:check-literal: -19401 # if t is an int, return -19402 (is-simple-mu-type? %esi 0) # literal => eax -19403 3d/compare-eax-and 0/imm32/false -19404 0f 85/jump-if-!= $check-mu-numberlike-arg:end/disp32 -19405 $check-mu-numberlike-arg:check-addr: -19406 # if t is an addr and v is dereferenced, return whether t->payload is an addr -19407 { -19408 (is-mu-addr-type? %esi) # => eax -19409 3d/compare-eax-and 0/imm32/false -19410 74/jump-if-= break/disp8 -19411 8b/-> *(ebp+8) 0/r32/eax -19412 8b/-> *(eax+0x10) 0/r32/eax # Stmt-var-is-deref -19413 3d/compare-eax-and 0/imm32/false -19414 { -19415 74/jump-if-= break/disp8 -19416 (lookup *(esi+0xc) *(esi+0x10)) # Type-tree-right Type-tree-right => eax -19417 # if t->right is null, t = t->left -19418 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -19419 { -19420 75/jump-if-!= break/disp8 -19421 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -19422 } -19423 (is-mu-addr-type? %eax) # => eax -19424 3d/compare-eax-and 0/imm32/false -19425 74/jump-if-= $check-mu-numberlike-arg:end/disp8 -19426 } -19427 } -19428 $check-mu-numberlike-arg:output-checks: -19429 (check-mu-numberlike-output *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18)) -19430 $check-mu-numberlike-arg:end: -19431 # . restore registers -19432 5e/pop-to-esi -19433 58/pop-to-eax -19434 # . epilogue -19435 89/<- %esp 5/r32/ebp -19436 5d/pop-to-ebp -19437 c3/return -19438 -19439 check-mu-numberlike-output: # v: (addr stmt-var), stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -19440 # . prologue -19441 55/push-ebp -19442 89/<- %ebp 4/r32/esp -19443 # . save registers -19444 50/push-eax -19445 # -19446 (is-mu-numberlike-output-var? *(ebp+8)) # => eax -19447 3d/compare-eax-and 0/imm32/false -19448 0f 84/jump-if-= $check-mu-numberlike-output:fail/disp32 -19449 $check-mu-numberlike-output:end: -19450 # . restore registers -19451 58/pop-to-eax -19452 # . epilogue -19453 89/<- %esp 5/r32/ebp -19454 5d/pop-to-ebp -19455 c3/return -19456 -19457 $check-mu-numberlike-output:fail: -19458 # otherwise raise an error -19459 (write-buffered *(ebp+0x14) "fn ") -19460 8b/-> *(ebp+0x10) 0/r32/eax -19461 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19462 (write-buffered *(ebp+0x14) %eax) -19463 (write-buffered *(ebp+0x14) ": stmt ") -19464 8b/-> *(ebp+0xc) 0/r32/eax -19465 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -19466 (write-buffered *(ebp+0x14) %eax) -19467 (write-buffered *(ebp+0x14) ": '") -19468 8b/-> *(ebp+8) 0/r32/eax -19469 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -19470 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19471 (write-buffered *(ebp+0x14) %eax) -19472 (write-buffered *(ebp+0x14) "' must be a non-addr non-offset scalar\n") -19473 (flush *(ebp+0x14)) -19474 (stop *(ebp+0x18) 1) -19475 # never gets here -19476 -19477 is-mu-numberlike-output-var?: # v: (addr stmt-var) -> result/eax: boolean -19478 # . prologue -19479 55/push-ebp -19480 89/<- %ebp 4/r32/esp -19481 # -19482 8b/-> *(ebp+8) 0/r32/eax -19483 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -19484 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19485 (is-mu-numberlike-output? %eax) # => eax -19486 $is-mu-numberlike-output-var?:end: -19487 # . epilogue -19488 89/<- %esp 5/r32/ebp -19489 5d/pop-to-ebp -19490 c3/return -19491 -19492 is-mu-numberlike-output?: # v: (addr type-tree) -> result/eax: boolean -19493 # . prologue -19494 55/push-ebp -19495 89/<- %ebp 4/r32/esp -19496 # . save registers -19497 56/push-esi -19498 # var t/esi: (addr type-tree) = lookup(v->value->type) -19499 8b/-> *(ebp+8) 6/r32/esi -19500 $is-mu-numberlike-output?:check-int: -19501 # if t is an int, return -19502 (is-simple-mu-type? %esi 1) # int => eax -19503 3d/compare-eax-and 0/imm32/false -19504 0f 85/jump-if-!= $is-mu-numberlike-output?:return-true/disp32 -19505 $is-mu-numberlike-output?:check-float: -19506 # if t is a float, return -19507 (is-simple-mu-type? %esi 0xf) # float => eax -19508 3d/compare-eax-and 0/imm32/false -19509 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 -19510 $is-mu-numberlike-output?:check-boolean: -19511 # if t is a boolean, return -19512 (is-simple-mu-type? %esi 5) # boolean => eax -19513 3d/compare-eax-and 0/imm32/false -19514 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 -19515 $is-mu-numberlike-output?:check-byte: -19516 # if t is a byte, return -19517 (is-simple-mu-type? %esi 8) # byte => eax -19518 3d/compare-eax-and 0/imm32/false -19519 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 -19520 $is-mu-numberlike-output?:check-code-point: -19521 # if t is a code-point, return -19522 (is-simple-mu-type? %esi 0xd) # code-point => eax -19523 3d/compare-eax-and 0/imm32/false -19524 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 -19525 $is-mu-numberlike-output?:check-grapheme: -19526 # if t is a grapheme, return -19527 (is-simple-mu-type? %esi 0xe) # grapheme => eax -19528 3d/compare-eax-and 0/imm32/false -19529 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 -19530 $is-mu-numberlike-output?:return-false: -19531 b8/copy-to-eax 0/imm32/false -19532 eb/jump $is-mu-numberlike-output?:end/disp8 -19533 $is-mu-numberlike-output?:return-true: -19534 b8/copy-to-eax 1/imm32/true -19535 $is-mu-numberlike-output?:end: -19536 # . restore registers -19537 5e/pop-to-esi +19247 $populate-mu-type-sizes:end: +19248 # . epilogue +19249 89/<- %esp 5/r32/ebp +19250 5d/pop-to-ebp +19251 c3/return +19252 +19253 # compute sizes of all fields, recursing as necessary +19254 # sum up all their sizes to arrive at total size +19255 # fields may be out of order, but that doesn't affect the answer +19256 populate-mu-type-sizes-in-type: # T: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) +19257 # . prologue +19258 55/push-ebp +19259 89/<- %ebp 4/r32/esp +19260 # . save registers +19261 50/push-eax +19262 51/push-ecx +19263 52/push-edx +19264 56/push-esi +19265 57/push-edi +19266 # esi = T +19267 8b/-> *(ebp+8) 6/r32/esi +19268 # if T is already computed, return +19269 81 7/subop/compare *(esi+0xc) 0/imm32 # Typeinfo-total-size-in-bytes +19270 0f 8d/jump-if->= $populate-mu-type-sizes-in-type:end/disp32 +19271 # if T is being computed, abort +19272 81 7/subop/compare *(esi+0xc) -1/imm32/being-computed # Typeinfo-total-size-in-bytes +19273 0f 84/jump-if-= $populate-mu-type-sizes-in-type:abort/disp32 +19274 # tag T (-2 to -1) to avoid infinite recursion +19275 c7 0/subop/copy *(esi+0xc) -1/imm32/being-computed # Typeinfo-total-size-in-bytes +19276 # var total-size/edi: int = 0 +19277 bf/copy-to-edi 0/imm32 +19278 # - for every field, if it's a user-defined type, compute its size +19279 # var table/ecx: (addr table (handle array byte) (handle typeinfo-entry)) = lookup(T->fields) +19280 (lookup *(esi+4) *(esi+8)) # Typeinfo-fields Typeinfo-fields => eax +19281 89/<- %ecx 0/r32/eax +19282 # var table-size/edx: int = table->write +19283 8b/-> *ecx 2/r32/edx # stream-write +19284 # var curr/ecx: (addr table_row) = table->data +19285 8d/copy-address *(ecx+0xc) 1/r32/ecx +19286 # var max/edx: (addr table_row) = table->data + table->write +19287 8d/copy-address *(ecx+edx) 2/r32/edx +19288 { +19289 $populate-mu-type-sizes-in-type:loop: +19290 # if (curr >= max) break +19291 39/compare %ecx 2/r32/edx +19292 73/jump-if-addr>= break/disp8 +19293 # var t/eax: (addr typeinfo-entry) = lookup(curr->value) +19294 (lookup *(ecx+8) *(ecx+0xc)) # => eax +19295 # if (t->input-var == 0) silently ignore it; we'll emit a nice error message while type-checking +19296 81 7/subop/compare *eax 0/imm32 # Typeinfo-entry-input-var +19297 74/jump-if-= $populate-mu-type-sizes-in-type:end/disp8 +19298 # compute size of t->input-var +19299 (lookup *eax *(eax+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax +19300 (compute-size-of-var %eax *(ebp+0xc) *(ebp+0x10)) # => eax +19301 # result += eax +19302 01/add-to %edi 0/r32/eax +19303 # curr += row-size +19304 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-fields-row-size +19305 # +19306 eb/jump loop/disp8 +19307 } +19308 # - save result +19309 89/<- *(esi+0xc) 7/r32/edi # Typeinfo-total-size-in-bytes +19310 $populate-mu-type-sizes-in-type:end: +19311 # . restore registers +19312 5f/pop-to-edi +19313 5e/pop-to-esi +19314 5a/pop-to-edx +19315 59/pop-to-ecx +19316 58/pop-to-eax +19317 # . epilogue +19318 89/<- %esp 5/r32/ebp +19319 5d/pop-to-ebp +19320 c3/return +19321 +19322 $populate-mu-type-sizes-in-type:abort: +19323 (write-buffered *(ebp+0xc) "cycle in type definitions\n") +19324 (flush *(ebp+0xc)) +19325 (stop *(ebp+0x10) 1) +19326 # never gets here +19327 +19328 # Analogous to size-of, except we need to compute what size-of can just read +19329 # off the right data structures. +19330 compute-size-of-var: # in: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +19331 # . prologue +19332 55/push-ebp +19333 89/<- %ebp 4/r32/esp +19334 # . push registers +19335 51/push-ecx +19336 # var t/ecx: (addr type-tree) = lookup(v->type) +19337 8b/-> *(ebp+8) 1/r32/ecx +19338 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +19339 89/<- %ecx 0/r32/eax +19340 # if (t->is-atom == false) t = lookup(t->left) +19341 { +19342 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +19343 75/jump-if-!= break/disp8 +19344 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +19345 89/<- %ecx 0/r32/eax +19346 } +19347 # TODO: ensure t is an atom +19348 (compute-size-of-type-id *(ecx+4) *(ebp+0xc) *(ebp+0x10)) # Type-tree-value => eax +19349 $compute-size-of-var:end: +19350 # . restore registers +19351 59/pop-to-ecx +19352 # . epilogue +19353 89/<- %esp 5/r32/ebp +19354 5d/pop-to-ebp +19355 c3/return +19356 +19357 compute-size-of-type-id: # t: type-id, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +19358 # . prologue +19359 55/push-ebp +19360 89/<- %ebp 4/r32/esp +19361 # . save registers +19362 51/push-ecx +19363 # var out/ecx: (handle typeinfo) +19364 68/push 0/imm32 +19365 68/push 0/imm32 +19366 89/<- %ecx 4/r32/esp +19367 # eax = t +19368 8b/-> *(ebp+8) 0/r32/eax +19369 # if t is a literal, return 0 +19370 3d/compare-eax-and 0/imm32/literal +19371 0f 84/jump-if-= $compute-size-of-type-id:end/disp32 # eax changes type from type-id to int +19372 # if t is a byte, return 4 (because we don't really support non-multiples of 4) +19373 3d/compare-eax-and 8/imm32/byte +19374 { +19375 75/jump-if-!= break/disp8 +19376 b8/copy-to-eax 4/imm32 +19377 eb/jump $compute-size-of-type-id:end/disp8 +19378 } +19379 # if t is a handle, return 8 +19380 3d/compare-eax-and 4/imm32/handle +19381 { +19382 75/jump-if-!= break/disp8 +19383 b8/copy-to-eax 8/imm32 +19384 eb/jump $compute-size-of-type-id:end/disp8 # eax changes type from type-id to int +19385 } +19386 # if t is a slice, return 8 +19387 3d/compare-eax-and 0xc/imm32/slice +19388 { +19389 75/jump-if-!= break/disp8 +19390 b8/copy-to-eax 8/imm32 +19391 eb/jump $compute-size-of-type-id:end/disp8 # eax changes type from type-id to int +19392 } +19393 # if t is a user-defined type, compute its size +19394 # TODO: support non-atom type +19395 (find-typeinfo %eax %ecx) +19396 { +19397 81 7/subop/compare *ecx 0/imm32 +19398 74/jump-if-= break/disp8 +19399 $compute-size-of-type-id:user-defined: +19400 (lookup *ecx *(ecx+4)) # => eax +19401 (populate-mu-type-sizes-in-type %eax *(ebp+0xc) *(ebp+0x10)) +19402 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes +19403 eb/jump $compute-size-of-type-id:end/disp8 +19404 } +19405 # otherwise return the word size +19406 b8/copy-to-eax 4/imm32 +19407 $compute-size-of-type-id:end: +19408 # . reclaim locals +19409 81 0/subop/add %esp 8/imm32 +19410 # . restore registers +19411 59/pop-to-ecx +19412 # . epilogue +19413 89/<- %esp 5/r32/ebp +19414 5d/pop-to-ebp +19415 c3/return +19416 +19417 # at this point we have total sizes for all user-defined types +19418 # compute offsets for each element +19419 # complication: fields may be out of order +19420 populate-mu-type-offsets: # in: (addr typeinfo), err: (addr buffered-file), ed: (addr exit-descriptor) +19421 # . prologue +19422 55/push-ebp +19423 89/<- %ebp 4/r32/esp +19424 # . save registers +19425 50/push-eax +19426 51/push-ecx +19427 52/push-edx +19428 53/push-ebx +19429 56/push-esi +19430 57/push-edi +19431 #? (dump-typeinfos "aaa\n") +19432 # var curr-offset/edi: int = 0 +19433 bf/copy-to-edi 0/imm32 +19434 # var table/ecx: (addr table string_key (handle typeinfo-entry)) = lookup(in->fields) +19435 8b/-> *(ebp+8) 1/r32/ecx +19436 (lookup *(ecx+4) *(ecx+8)) # Typeinfo-fields Typeinfo-fields => eax +19437 89/<- %ecx 0/r32/eax +19438 # var num-elems/edx: int = table->write / Typeinfo-fields-row-size +19439 8b/-> *ecx 2/r32/edx # stream-write +19440 c1 5/subop/shift-right-logical %edx 4/imm8 +19441 # var i/ebx: int = 0 +19442 bb/copy-to-ebx 0/imm32 +19443 { +19444 $populate-mu-type-offsets:loop: +19445 39/compare %ebx 2/r32/edx +19446 0f 8d/jump-if->= break/disp32 +19447 #? (write-buffered Stderr "looking up index ") +19448 #? (write-int32-hex-buffered Stderr %ebx) +19449 #? (write-buffered Stderr " in ") +19450 #? (write-int32-hex-buffered Stderr *(ebp+8)) +19451 #? (write-buffered Stderr Newline) +19452 #? (flush Stderr) +19453 # var v/esi: (addr typeinfo-entry) +19454 (locate-typeinfo-entry-with-index %ecx %ebx *(ebp+0xc) *(ebp+0x10)) # => eax +19455 89/<- %esi 0/r32/eax +19456 # if v is null, silently move on; we'll emit a nice error message while type-checking +19457 81 7/subop/compare %esi 0/imm32 # Typeinfo-entry-input-var +19458 74/jump-if-= $populate-mu-type-offsets:end/disp8 +19459 # if (v->input-var == 0) silently ignore v; we'll emit a nice error message while type-checking +19460 81 7/subop/compare *esi 0/imm32 # Typeinfo-entry-input-var +19461 74/jump-if-= $populate-mu-type-offsets:end/disp8 +19462 # v->output-var->offset = curr-offset +19463 # . eax: (addr var) +19464 (lookup *(esi+0xc) *(esi+0x10)) # Typeinfo-entry-output-var Typeinfo-entry-output-var => eax +19465 89/<- *(eax+0x14) 7/r32/edi # Var-offset +19466 # curr-offset += size-of(v->input-var) +19467 (lookup *esi *(esi+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax +19468 (size-of %eax) # => eax +19469 01/add-to %edi 0/r32/eax +19470 # ++i +19471 43/increment-ebx +19472 e9/jump loop/disp32 +19473 } +19474 $populate-mu-type-offsets:end: +19475 # . restore registers +19476 5f/pop-to-edi +19477 5e/pop-to-esi +19478 5b/pop-to-ebx +19479 5a/pop-to-edx +19480 59/pop-to-ecx +19481 58/pop-to-eax +19482 # . epilogue +19483 89/<- %esp 5/r32/ebp +19484 5d/pop-to-ebp +19485 c3/return +19486 +19487 locate-typeinfo-entry-with-index: # table: (addr table (handle array byte) (handle typeinfo-entry)), idx: int, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: (addr typeinfo-entry) +19488 # . prologue +19489 55/push-ebp +19490 89/<- %ebp 4/r32/esp +19491 # . save registers +19492 51/push-ecx +19493 52/push-edx +19494 53/push-ebx +19495 56/push-esi +19496 57/push-edi +19497 # esi = table +19498 8b/-> *(ebp+8) 6/r32/esi +19499 # var curr/ecx: (addr row (handle array byte) (handle typeinfo-entry)) = table->data +19500 8d/copy-address *(esi+0xc) 1/r32/ecx +19501 # var max/edx: (addr byte) = &table->data[table->write] +19502 8b/-> *esi 2/r32/edx +19503 8d/copy-address *(ecx+edx) 2/r32/edx +19504 { +19505 $locate-typeinfo-entry-with-index:loop: +19506 39/compare %ecx 2/r32/edx +19507 73/jump-if-addr>= break/disp8 +19508 # var v/eax: (addr typeinfo-entry) +19509 (lookup *(ecx+8) *(ecx+0xc)) # => eax +19510 # if (v->index == idx) return v +19511 8b/-> *(eax+8) 3/r32/ebx # Typeinfo-entry-index +19512 #? (write-buffered Stderr "comparing ") +19513 #? (write-int32-hex-buffered Stderr %ebx) +19514 #? (write-buffered Stderr " and ") +19515 #? (write-int32-hex-buffered Stderr *(ebp+0xc)) +19516 #? (write-buffered Stderr Newline) +19517 #? (flush Stderr) +19518 39/compare *(ebp+0xc) 3/r32/ebx +19519 74/jump-if-= $locate-typeinfo-entry-with-index:end/disp8 +19520 # curr += Typeinfo-entry-size +19521 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-entry-size +19522 # +19523 eb/jump loop/disp8 +19524 } +19525 # return 0 +19526 b8/copy-to-eax 0/imm32 +19527 $locate-typeinfo-entry-with-index:end: +19528 #? (write-buffered Stderr "returning ") +19529 #? (write-int32-hex-buffered Stderr %eax) +19530 #? (write-buffered Stderr Newline) +19531 #? (flush Stderr) +19532 # . restore registers +19533 5f/pop-to-edi +19534 5e/pop-to-esi +19535 5b/pop-to-ebx +19536 5a/pop-to-edx +19537 59/pop-to-ecx 19538 # . epilogue 19539 89/<- %esp 5/r32/ebp 19540 5d/pop-to-ebp 19541 c3/return 19542 -19543 check-mu-copy-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +19543 dump-typeinfos: # hdr: (addr array byte) 19544 # . prologue 19545 55/push-ebp 19546 89/<- %ebp 4/r32/esp 19547 # . save registers 19548 50/push-eax -19549 51/push-ecx -19550 52/push-edx -19551 56/push-esi -19552 57/push-edi -19553 # var type-parameters/edx: (addr table (handle array byte) (addr type-tree) 8) -19554 81 5/subop/subtract %esp 0x60/imm32 -19555 68/push 0x60/imm32/size -19556 68/push 0/imm32/read -19557 68/push 0/imm32/write -19558 89/<- %edx 4/r32/esp -19559 $check-mu-copy-stmt:get-output: -19560 # esi = stmt -19561 8b/-> *(ebp+8) 6/r32/esi -19562 # var output/edi: (addr stmt-var) = stmt->outputs -19563 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -19564 89/<- %edi 0/r32/eax -19565 # zero outputs -19566 3d/compare-eax-and 0/imm32 -19567 0f 84/jump-if-= $check-mu-copy-stmt:error-no-output/disp32 -19568 # > 1 output -19569 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -19570 3d/compare-eax-and 0/imm32 -19571 0f 85/jump-if-!= $check-mu-copy-stmt:error-too-many-outputs/disp32 -19572 $check-mu-copy-stmt:get-inout: -19573 # var inout/esi: (addr stmt-var) = stmt->inouts -19574 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -19575 89/<- %esi 0/r32/eax -19576 # zero inouts -19577 3d/compare-eax-and 0/imm32 -19578 0f 84/jump-if-= $check-mu-copy-stmt:error-no-inout/disp32 -19579 # > 1 inout -19580 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -19581 3d/compare-eax-and 0/imm32 -19582 0f 85/jump-if-!= $check-mu-copy-stmt:error-too-many-inouts/disp32 -19583 $check-mu-copy-stmt:types: -19584 # var inout-type/ecx: (addr type-tree) = inout->value->type -19585 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19586 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19587 89/<- %ecx 0/r32/eax -19588 # if (inout->is-deref?) inout-type = inout-type->payload -19589 8b/-> *(esi+0x10) 0/r32/eax # Stmt-var-is-deref -19590 3d/compare-eax-and 0/imm32/false -19591 { -19592 74/jump-if-= break/disp8 -19593 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -19594 # if inout-type->right is null, t = inout-type->left -19595 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -19596 { -19597 75/jump-if-!= break/disp8 -19598 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -19599 } -19600 89/<- %ecx 0/r32/eax -19601 } -19602 # if output not in register, abort -19603 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19604 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -19605 3d/compare-eax-and 0/imm32 -19606 0f 84/jump-if-= $check-mu-copy-stmt:error-output-not-in-register/disp32 -19607 # if inout is not a scalar, abort -19608 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19609 (size-of %eax) # => eax -19610 3d/compare-eax-and 4/imm32 -19611 0f 8f/jump-if-> $check-mu-copy-stmt:error-inout-too-large/disp32 -19612 # var output-type/eax: (addr type-tree) = output->value->type -19613 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19614 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19615 # if (inout-type == output-type) return -19616 (type-match? %eax %ecx %edx) # => eax -19617 3d/compare-eax-and 0/imm32 -19618 0f 85/jump-if-!= $check-mu-copy-stmt:end/disp32 -19619 # if output is an addr and inout is 0, return -19620 { -19621 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19622 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19623 (is-mu-addr-type? %eax) # => eax -19624 3d/compare-eax-and 0/imm32/false -19625 74/jump-if-= break/disp8 -19626 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19627 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19628 (string-equal? %eax "0") # => eax -19629 3d/compare-eax-and 0/imm32/false -19630 74/jump-if-= break/disp8 -19631 e9/jump $check-mu-copy-stmt:end/disp32 -19632 } -19633 # if output is an offset and inout is 0, return -19634 { -19635 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19636 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19637 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -19638 75/jump-if-!= break/disp8 -19639 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -19640 (is-simple-mu-type? %eax 7) # offset => eax -19641 3d/compare-eax-and 0/imm32/false -19642 74/jump-if-= break/disp8 -19643 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19644 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19645 (string-equal? %eax "0") # => eax -19646 3d/compare-eax-and 0/imm32/false -19647 74/jump-if-= break/disp8 -19648 eb/jump $check-mu-copy-stmt:end/disp8 -19649 } -19650 # if output is not number-like, abort -19651 (check-mu-numberlike-output %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19652 $check-mu-copy-stmt:end: -19653 # . reclaim locals -19654 81 0/subop/add %esp 0x6c/imm32 -19655 # . restore registers -19656 5f/pop-to-edi -19657 5e/pop-to-esi -19658 5a/pop-to-edx -19659 59/pop-to-ecx -19660 58/pop-to-eax -19661 # . epilogue -19662 89/<- %esp 5/r32/ebp -19663 5d/pop-to-ebp -19664 c3/return -19665 -19666 $check-mu-copy-stmt:error-no-inout: -19667 (write-buffered *(ebp+0x10) "fn ") -19668 8b/-> *(ebp+0xc) 0/r32/eax -19669 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19670 (write-buffered *(ebp+0x10) %eax) -19671 (write-buffered *(ebp+0x10) ": stmt 'copy' expects an inout\n") -19672 (flush *(ebp+0x10)) -19673 (stop *(ebp+0x14) 1) -19674 # never gets here -19675 -19676 $check-mu-copy-stmt:error-too-many-inouts: -19677 (write-buffered *(ebp+0x10) "fn ") -19678 8b/-> *(ebp+0xc) 0/r32/eax -19679 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19680 (write-buffered *(ebp+0x10) %eax) -19681 (write-buffered *(ebp+0x10) ": stmt 'copy' must have just one inout\n") -19682 (flush *(ebp+0x10)) -19683 (stop *(ebp+0x14) 1) -19684 # never gets here -19685 -19686 $check-mu-copy-stmt:error-no-output: -19687 (write-buffered *(ebp+0x10) "fn ") -19688 8b/-> *(ebp+0xc) 0/r32/eax -19689 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19690 (write-buffered *(ebp+0x10) %eax) -19691 (write-buffered *(ebp+0x10) ": stmt 'copy' expects an output\n") -19692 (flush *(ebp+0x10)) -19693 (stop *(ebp+0x14) 1) -19694 # never gets here -19695 -19696 $check-mu-copy-stmt:error-output-not-in-register: -19697 (write-buffered *(ebp+0x10) "fn ") -19698 8b/-> *(ebp+0xc) 0/r32/eax -19699 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19700 (write-buffered *(ebp+0x10) %eax) -19701 (write-buffered *(ebp+0x10) ": stmt copy: output '") -19702 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19703 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19704 (write-buffered *(ebp+0x10) %eax) -19705 (write-buffered *(ebp+0x10) "' not in a register\n") -19706 (flush *(ebp+0x10)) -19707 (stop *(ebp+0x14) 1) -19708 # never gets here -19709 -19710 $check-mu-copy-stmt:error-too-many-outputs: -19711 (write-buffered *(ebp+0x10) "fn ") -19712 8b/-> *(ebp+0xc) 0/r32/eax -19713 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19714 (write-buffered *(ebp+0x10) %eax) -19715 (write-buffered *(ebp+0x10) ": stmt 'copy' must have just one output\n") -19716 (flush *(ebp+0x10)) -19717 (stop *(ebp+0x14) 1) -19718 # never gets here -19719 -19720 $check-mu-copy-stmt:error-inout-too-large: -19721 (write-buffered *(ebp+0x10) "fn ") -19722 8b/-> *(ebp+0xc) 0/r32/eax -19723 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19724 (write-buffered *(ebp+0x10) %eax) -19725 (write-buffered *(ebp+0x10) ": stmt copy: '") -19726 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19727 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19728 (write-buffered *(ebp+0x10) %eax) -19729 (write-buffered *(ebp+0x10) "' is too large to fit in a register\n") -19730 (flush *(ebp+0x10)) -19731 (stop *(ebp+0x14) 1) -19732 # never gets here -19733 -19734 check-mu-copy-to-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -19735 # . prologue -19736 55/push-ebp -19737 89/<- %ebp 4/r32/esp -19738 # . save registers -19739 50/push-eax -19740 51/push-ecx -19741 52/push-edx -19742 53/push-ebx -19743 56/push-esi -19744 57/push-edi -19745 # var type-parameters/edx: (addr table (handle array byte) (addr type-tree) 8) -19746 81 5/subop/subtract %esp 0x60/imm32 -19747 68/push 0x60/imm32/size -19748 68/push 0/imm32/read -19749 68/push 0/imm32/write -19750 89/<- %edx 4/r32/esp -19751 # esi = stmt -19752 8b/-> *(ebp+8) 6/r32/esi -19753 $check-mu-copy-to-stmt:check-for-output: -19754 # if stmt->outputs abort -19755 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -19756 3d/compare-eax-and 0/imm32 -19757 0f 85/jump-if-!= $check-mu-copy-to-stmt:error-too-many-outputs/disp32 -19758 $check-mu-copy-to-stmt:get-dest: -19759 # var dest/edi: (addr stmt-var) = stmt->inouts -19760 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -19761 89/<- %edi 0/r32/eax -19762 # zero inouts -19763 3d/compare-eax-and 0/imm32 -19764 0f 84/jump-if-= $check-mu-copy-to-stmt:error-incorrect-inouts/disp32 -19765 $check-mu-copy-to-stmt:get-src: -19766 # var src/esi: (addr stmt-var) = dest->next -19767 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -19768 89/<- %esi 0/r32/eax -19769 # 1 inout -19770 3d/compare-eax-and 0/imm32 -19771 0f 84/jump-if-= $check-mu-copy-to-stmt:error-incorrect-inouts/disp32 -19772 # > 2 inouts -19773 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -19774 3d/compare-eax-and 0/imm32 -19775 0f 85/jump-if-!= $check-mu-copy-to-stmt:error-incorrect-inouts/disp32 -19776 $check-mu-copy-to-stmt:types: -19777 # var src-type/ecx: (addr type-tree) = src->value->type -19778 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19779 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19780 89/<- %ecx 0/r32/eax -19781 # if src not in register or literal, abort -19782 # (we can't use stack-offset because it hasn't been computed yet) -19783 { -19784 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19785 (lookup *(eax+0x8) *(eax+0xc)) # Var-type Var-type => eax -19786 (is-simple-mu-type? %eax 0) # => eax -19787 3d/compare-eax-and 0/imm32 -19788 75/jump-if-!= break/disp8 -19789 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19790 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -19791 3d/compare-eax-and 0/imm32 -19792 75/jump-if-!= break/disp8 -19793 e9/jump $check-mu-copy-to-stmt:error-src-not-literal-or-in-register/disp32 -19794 } -19795 # if src is not a scalar, abort -19796 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19797 (size-of %eax) # => eax -19798 3d/compare-eax-and 4/imm32 -19799 0f 8f/jump-if-> $check-mu-copy-to-stmt:error-src-too-large/disp32 -19800 # var dest-type/ebx: (addr type-tree) = dest->value->type -19801 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19802 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19803 89/<- %ebx 0/r32/eax -19804 # if (dest->is-deref?) dest-type = dest-type->payload -19805 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref -19806 3d/compare-eax-and 0/imm32/false -19807 { -19808 74/jump-if-= break/disp8 -19809 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -19810 # if dest-type->right is null, dest-type = dest-type->left -19811 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -19812 { -19813 75/jump-if-!= break/disp8 -19814 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -19815 } -19816 89/<- %ebx 0/r32/eax -19817 } -19818 # if (src-type == dest-type) return -19819 (type-match? %ebx %ecx %edx) # => eax -19820 3d/compare-eax-and 0/imm32 -19821 0f 85/jump-if-!= $check-mu-copy-to-stmt:end/disp32 -19822 # if dest is an addr and src is 0, return +19549 # +19550 (write-buffered Stderr *(ebp+8)) +19551 (flush Stderr) +19552 # var curr/eax: (addr typeinfo) = lookup(Program->types) +19553 (lookup *_Program-types *_Program-types->payload) # => eax +19554 { +19555 # if (curr == null) break +19556 3d/compare-eax-and 0/imm32 +19557 74/jump-if-= break/disp8 +19558 (write-buffered Stderr "---\n") +19559 (flush Stderr) +19560 (dump-typeinfo %eax) +19561 # curr = lookup(curr->next) +19562 (lookup *(eax+0x10) *(eax+0x14)) # Typeinfo-next Typeinfo-next => eax +19563 eb/jump loop/disp8 +19564 } +19565 $dump-typeinfos:end: +19566 # . restore registers +19567 58/pop-to-eax +19568 # . epilogue +19569 89/<- %esp 5/r32/ebp +19570 5d/pop-to-ebp +19571 c3/return +19572 +19573 dump-typeinfo: # in: (addr typeinfo) +19574 # . prologue +19575 55/push-ebp +19576 89/<- %ebp 4/r32/esp +19577 # . save registers +19578 50/push-eax +19579 51/push-ecx +19580 52/push-edx +19581 53/push-ebx +19582 56/push-esi +19583 57/push-edi +19584 # esi = in +19585 8b/-> *(ebp+8) 6/r32/esi +19586 # var table/ecx: (addr table (handle array byte) (handle typeinfo-entry)) = lookup(T->fields) +19587 (lookup *(esi+4) *(esi+8)) # Typeinfo-fields Typeinfo-fields => eax +19588 89/<- %ecx 0/r32/eax +19589 (write-buffered Stderr "id:") +19590 (write-int32-hex-buffered Stderr *esi) +19591 (write-buffered Stderr "\n") +19592 (write-buffered Stderr "fields @ ") +19593 (write-int32-hex-buffered Stderr %ecx) +19594 (write-buffered Stderr Newline) +19595 (flush Stderr) +19596 (write-buffered Stderr " write: ") +19597 (write-int32-hex-buffered Stderr *ecx) +19598 (write-buffered Stderr Newline) +19599 (flush Stderr) +19600 (write-buffered Stderr " read: ") +19601 (write-int32-hex-buffered Stderr *(ecx+4)) +19602 (write-buffered Stderr Newline) +19603 (flush Stderr) +19604 (write-buffered Stderr " size: ") +19605 (write-int32-hex-buffered Stderr *(ecx+8)) +19606 (write-buffered Stderr Newline) +19607 (flush Stderr) +19608 # var table-size/edx: int = table->write +19609 8b/-> *ecx 2/r32/edx # stream-write +19610 # var curr/ecx: (addr table_row) = table->data +19611 8d/copy-address *(ecx+0xc) 1/r32/ecx +19612 # var max/edx: (addr table_row) = table->data + table->write +19613 8d/copy-address *(ecx+edx) 2/r32/edx +19614 { +19615 $dump-typeinfo:loop: +19616 # if (curr >= max) break +19617 39/compare %ecx 2/r32/edx +19618 0f 83/jump-if-addr>= break/disp32 +19619 (write-buffered Stderr " row:\n") +19620 (write-buffered Stderr " key: ") +19621 (write-int32-hex-buffered Stderr *ecx) +19622 (write-buffered Stderr ",") +19623 (write-int32-hex-buffered Stderr *(ecx+4)) +19624 (write-buffered Stderr " = '") +19625 (lookup *ecx *(ecx+4)) +19626 (write-buffered Stderr %eax) +19627 (write-buffered Stderr "' @ ") +19628 (write-int32-hex-buffered Stderr %eax) +19629 (write-buffered Stderr Newline) +19630 (flush Stderr) +19631 (write-buffered Stderr " value: ") +19632 (write-int32-hex-buffered Stderr *(ecx+8)) +19633 (write-buffered Stderr ",") +19634 (write-int32-hex-buffered Stderr *(ecx+0xc)) +19635 (write-buffered Stderr " = typeinfo-entry@") +19636 (lookup *(ecx+8) *(ecx+0xc)) +19637 (write-int32-hex-buffered Stderr %eax) +19638 (write-buffered Stderr Newline) +19639 (flush Stderr) +19640 (write-buffered Stderr " input var@") +19641 (dump-var 5 %eax) +19642 (lookup *(ecx+8) *(ecx+0xc)) +19643 (write-buffered Stderr " index: ") +19644 (write-int32-hex-buffered Stderr *(eax+8)) +19645 (write-buffered Stderr Newline) +19646 (flush Stderr) +19647 (write-buffered Stderr " output var@") +19648 8d/copy-address *(eax+0xc) 0/r32/eax # Typeinfo-entry-output-var +19649 (dump-var 5 %eax) +19650 (flush Stderr) +19651 # curr += row-size +19652 81 0/subop/add %ecx 0x10/imm32 # Typeinfo-fields-row-size +19653 # +19654 e9/jump loop/disp32 +19655 } +19656 $dump-typeinfo:end: +19657 # . restore registers +19658 5f/pop-to-edi +19659 5e/pop-to-esi +19660 5b/pop-to-ebx +19661 5a/pop-to-edx +19662 59/pop-to-ecx +19663 58/pop-to-eax +19664 # . epilogue +19665 89/<- %esp 5/r32/ebp +19666 5d/pop-to-ebp +19667 c3/return +19668 +19669 dump-var: # indent: int, v: (addr handle var) +19670 # . prologue +19671 55/push-ebp +19672 89/<- %ebp 4/r32/esp +19673 # . save registers +19674 50/push-eax +19675 53/push-ebx +19676 # eax = v +19677 8b/-> *(ebp+0xc) 0/r32/eax +19678 # +19679 (write-int32-hex-buffered Stderr *eax) +19680 (write-buffered Stderr ",") +19681 (write-int32-hex-buffered Stderr *(eax+4)) +19682 (write-buffered Stderr "->") +19683 (lookup *eax *(eax+4)) +19684 (write-int32-hex-buffered Stderr %eax) +19685 (write-buffered Stderr Newline) +19686 (flush Stderr) +19687 { +19688 3d/compare-eax-and 0/imm32 +19689 0f 84/jump-if-= break/disp32 +19690 (emit-indent Stderr *(ebp+8)) +19691 (write-buffered Stderr "name: ") +19692 89/<- %ebx 0/r32/eax +19693 (write-int32-hex-buffered Stderr *ebx) # Var-name +19694 (write-buffered Stderr ",") +19695 (write-int32-hex-buffered Stderr *(ebx+4)) # Var-name +19696 (write-buffered Stderr "->") +19697 (lookup *ebx *(ebx+4)) # Var-name +19698 (write-int32-hex-buffered Stderr %eax) +19699 { +19700 3d/compare-eax-and 0/imm32 +19701 74/jump-if-= break/disp8 +19702 (write-buffered Stderr Space) +19703 (write-buffered Stderr %eax) +19704 } +19705 (write-buffered Stderr Newline) +19706 (flush Stderr) +19707 (emit-indent Stderr *(ebp+8)) +19708 (write-buffered Stderr "block depth: ") +19709 (write-int32-hex-buffered Stderr *(ebx+0x10)) # Var-block-depth +19710 (write-buffered Stderr Newline) +19711 (flush Stderr) +19712 (emit-indent Stderr *(ebp+8)) +19713 (write-buffered Stderr "stack offset: ") +19714 (write-int32-hex-buffered Stderr *(ebx+0x14)) # Var-offset +19715 (write-buffered Stderr Newline) +19716 (flush Stderr) +19717 (emit-indent Stderr *(ebp+8)) +19718 (write-buffered Stderr "reg: ") +19719 (write-int32-hex-buffered Stderr *(ebx+0x18)) # Var-register +19720 (write-buffered Stderr ",") +19721 (write-int32-hex-buffered Stderr *(ebx+0x1c)) # Var-register +19722 (write-buffered Stderr "->") +19723 (flush Stderr) +19724 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register +19725 (write-int32-hex-buffered Stderr %eax) +19726 { +19727 3d/compare-eax-and 0/imm32 +19728 74/jump-if-= break/disp8 +19729 (write-buffered Stderr Space) +19730 (write-buffered Stderr %eax) +19731 } +19732 (write-buffered Stderr Newline) +19733 (flush Stderr) +19734 } +19735 $dump-var:end: +19736 # . restore registers +19737 5b/pop-to-ebx +19738 58/pop-to-eax +19739 # . epilogue +19740 89/<- %esp 5/r32/ebp +19741 5d/pop-to-ebp +19742 c3/return +19743 +19744 ####################################################### +19745 # Type-checking +19746 ####################################################### +19747 +19748 check-mu-types: # err: (addr buffered-file), ed: (addr exit-descriptor) +19749 # . prologue +19750 55/push-ebp +19751 89/<- %ebp 4/r32/esp +19752 # . save registers +19753 50/push-eax +19754 # var curr/eax: (addr function) = lookup(Program->functions) +19755 (lookup *_Program-functions *_Program-functions->payload) # => eax +19756 { +19757 $check-mu-types:loop: +19758 # if (curr == null) break +19759 3d/compare-eax-and 0/imm32 +19760 0f 84/jump-if-= break/disp32 +19761 +-- 8 lines: #? # dump curr->name --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +19769 (check-mu-function %eax *(ebp+8) *(ebp+0xc)) +19770 # curr = lookup(curr->next) +19771 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax +19772 e9/jump loop/disp32 +19773 } +19774 $check-mu-types:end: +19775 # . restore registers +19776 58/pop-to-eax +19777 # . epilogue +19778 89/<- %esp 5/r32/ebp +19779 5d/pop-to-ebp +19780 c3/return +19781 +19782 check-mu-function: # fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +19783 # . prologue +19784 55/push-ebp +19785 89/<- %ebp 4/r32/esp +19786 # . save registers +19787 50/push-eax +19788 56/push-esi +19789 # esi = f +19790 8b/-> *(ebp+8) 6/r32/esi +19791 # outputs +19792 (lookup *(esi+0x10) *(esi+0x14)) # Function-outputs Function-outputs => eax +19793 (check-all-unique-registers %eax %esi *(ebp+0xc) *(ebp+0x10)) +19794 # body +19795 (lookup *(esi+0x18) *(esi+0x1c)) # Function-body Function-body => eax +19796 (check-mu-block %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10)) +19797 # if function has no outputs, we're done +19798 81 7/subop/compare *(esi+0x10) 0/imm32 +19799 74/jump-if-= $check-mu-function:end/disp8 +19800 # some final checks on body +19801 (check-final-stmt-is-return %eax %esi *(ebp+0xc) *(ebp+0x10)) +19802 (check-no-breaks %eax %esi *(ebp+0xc) *(ebp+0x10)) +19803 $check-mu-function:end: +19804 # . restore registers +19805 5e/pop-to-esi +19806 58/pop-to-eax +19807 # . epilogue +19808 89/<- %esp 5/r32/ebp +19809 5d/pop-to-ebp +19810 c3/return +19811 +19812 check-mu-block: # block: (addr block), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +19813 # . prologue +19814 55/push-ebp +19815 89/<- %ebp 4/r32/esp +19816 # . save registers +19817 50/push-eax +19818 # eax = block +19819 8b/-> *(ebp+8) 0/r32/eax +19820 # var stmts/eax: (addr list stmt) = lookup(block->statements) +19821 (lookup *(eax+4) *(eax+8)) # Block-stmts Block-stmts => eax +19822 # 19823 { -19824 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19825 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19826 (is-mu-addr-type? %eax) # => eax -19827 3d/compare-eax-and 0/imm32/false -19828 74/jump-if-= break/disp8 -19829 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19830 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19831 (string-equal? %eax "0") # => eax -19832 3d/compare-eax-and 0/imm32/false -19833 74/jump-if-= break/disp8 -19834 eb/jump $check-mu-copy-to-stmt:end/disp8 -19835 } -19836 # if dest is not number-like, abort -19837 (check-mu-numberlike-arg %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -19838 $check-mu-copy-to-stmt:end: -19839 # . reclaim locals -19840 81 0/subop/add %esp 0x6c/imm32 -19841 # . restore registers -19842 5f/pop-to-edi -19843 5e/pop-to-esi -19844 5b/pop-to-ebx -19845 5a/pop-to-edx -19846 59/pop-to-ecx -19847 58/pop-to-eax -19848 # . epilogue -19849 89/<- %esp 5/r32/ebp -19850 5d/pop-to-ebp -19851 c3/return -19852 -19853 $check-mu-copy-to-stmt:error-incorrect-inouts: -19854 (write-buffered *(ebp+0x10) "fn ") -19855 8b/-> *(ebp+0xc) 0/r32/eax -19856 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19857 (write-buffered *(ebp+0x10) %eax) -19858 (write-buffered *(ebp+0x10) ": stmt 'copy-to' must have two inouts\n") -19859 (flush *(ebp+0x10)) -19860 (stop *(ebp+0x14) 1) -19861 # never gets here -19862 -19863 $check-mu-copy-to-stmt:error-too-many-outputs: -19864 (write-buffered *(ebp+0x10) "fn ") -19865 8b/-> *(ebp+0xc) 0/r32/eax -19866 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19867 (write-buffered *(ebp+0x10) %eax) -19868 (write-buffered *(ebp+0x10) ": stmt 'copy-to' must not have any outputs\n") -19869 (flush *(ebp+0x10)) -19870 (stop *(ebp+0x14) 1) -19871 # never gets here -19872 -19873 $check-mu-copy-to-stmt:error-src-not-literal-or-in-register: -19874 (write-buffered *(ebp+0x10) "fn ") -19875 8b/-> *(ebp+0xc) 0/r32/eax -19876 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19877 (write-buffered *(ebp+0x10) %eax) -19878 (write-buffered *(ebp+0x10) ": stmt copy-to: source (second inout) is in memory\n") -19879 (flush *(ebp+0x10)) -19880 (stop *(ebp+0x14) 1) -19881 # never gets here -19882 -19883 $check-mu-copy-to-stmt:error-src-too-large: -19884 (write-buffered *(ebp+0x10) "fn ") -19885 8b/-> *(ebp+0xc) 0/r32/eax -19886 (lookup *eax *(eax+4)) # Function-name Function-name => eax -19887 (write-buffered *(ebp+0x10) %eax) -19888 (write-buffered *(ebp+0x10) ": stmt copy-to: '") -19889 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19890 (lookup *eax *(eax+4)) # Var-name Var-name => eax -19891 (write-buffered *(ebp+0x10) %eax) -19892 (write-buffered *(ebp+0x10) "' is too large to copy\n") -19893 (flush *(ebp+0x10)) -19894 (stop *(ebp+0x14) 1) -19895 # never gets here -19896 -19897 check-mu-compare-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -19898 # . prologue -19899 55/push-ebp -19900 89/<- %ebp 4/r32/esp -19901 # . save registers -19902 50/push-eax -19903 51/push-ecx -19904 52/push-edx -19905 53/push-ebx -19906 56/push-esi -19907 57/push-edi -19908 # var type-parameters/edx: (addr table (handle array byte) (addr type-tree) 8) -19909 81 5/subop/subtract %esp 0x60/imm32 -19910 68/push 0x60/imm32/size -19911 68/push 0/imm32/read -19912 68/push 0/imm32/write -19913 89/<- %edx 4/r32/esp -19914 # esi = stmt -19915 8b/-> *(ebp+8) 6/r32/esi -19916 $check-mu-compare-stmt:check-for-output: -19917 # if stmt->outputs abort -19918 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +19824 $check-mu-block:check-empty: +19825 3d/compare-eax-and 0/imm32 +19826 0f 84/jump-if-= break/disp32 +19827 # emit block->statements +19828 (check-mu-stmt-list %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +19829 } +19830 $check-mu-block:end: +19831 # . restore registers +19832 58/pop-to-eax +19833 # . epilogue +19834 89/<- %esp 5/r32/ebp +19835 5d/pop-to-ebp +19836 c3/return +19837 +19838 check-mu-stmt-list: # stmts: (addr list stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +19839 # . prologue +19840 55/push-ebp +19841 89/<- %ebp 4/r32/esp +19842 # . save registers +19843 50/push-eax +19844 56/push-esi +19845 # esi = stmts +19846 8b/-> *(ebp+8) 6/r32/esi +19847 { +19848 $check-mu-stmt-list:loop: +19849 81 7/subop/compare %esi 0/imm32 +19850 0f 84/jump-if-= break/disp32 +19851 # var curr-stmt/eax: (addr stmt) = lookup(stmts->value) +19852 (lookup *esi *(esi+4)) # List-value List-value => eax +19853 { +19854 $check-mu-stmt-list:check-for-block: +19855 81 7/subop/compare *eax 0/imm32/block # Stmt-tag +19856 75/jump-if-!= break/disp8 +19857 $check-mu-stmt-list:block: +19858 (check-mu-block %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +19859 eb/jump $check-mu-stmt-list:continue/disp8 +19860 } +19861 { +19862 $check-mu-stmt-list:check-for-stmt1: +19863 81 7/subop/compare *eax 1/imm32/stmt1 # Stmt-tag +19864 0f 85/jump-if-!= break/disp32 +19865 $check-mu-stmt-list:stmt1: +19866 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +19867 eb/jump $check-mu-stmt-list:continue/disp8 +19868 } +19869 { +19870 $check-mu-stmt-list:check-for-reg-var-def: +19871 81 7/subop/compare *eax 3/imm32/reg-var-def # Stmt-tag +19872 0f 85/jump-if-!= break/disp32 +19873 $check-mu-stmt-list:reg-var-def: +19874 (check-mu-stmt %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +19875 eb/jump $check-mu-stmt-list:continue/disp8 +19876 } +19877 $check-mu-stmt-list:continue: +19878 # TODO: raise an error on unrecognized Stmt-tag +19879 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax +19880 89/<- %esi 0/r32/eax +19881 e9/jump loop/disp32 +19882 } +19883 $check-mu-stmt-list:end: +19884 # . restore registers +19885 5e/pop-to-esi +19886 58/pop-to-eax +19887 # . epilogue +19888 89/<- %esp 5/r32/ebp +19889 5d/pop-to-ebp +19890 c3/return +19891 +19892 check-mu-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +19893 # . prologue +19894 55/push-ebp +19895 89/<- %ebp 4/r32/esp +19896 # . save registers +19897 50/push-eax +19898 # - if stmt's operation matches a primitive, check against it +19899 (has-primitive-name? *(ebp+8)) # => eax +19900 3d/compare-eax-and 0/imm32/false +19901 { +19902 74/jump-if-= break/disp8 +19903 (check-mu-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +19904 e9/jump $check-mu-stmt:end/disp32 +19905 } +19906 # - otherwise find a function to check against +19907 # var f/eax: (addr function) = lookup(*Program->functions) +19908 (lookup *_Program-functions *_Program-functions->payload) # => eax +19909 (find-matching-function %eax *(ebp+8)) # => eax +19910 3d/compare-eax-and 0/imm32 +19911 { +19912 74/jump-if-= break/disp8 +19913 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +19914 eb/jump $check-mu-stmt:end/disp8 +19915 } +19916 # var f/eax: (addr function) = lookup(*Program->signatures) +19917 (lookup *_Program-signatures *_Program-signatures->payload) # => eax +19918 (find-matching-function %eax *(ebp+8)) # => eax 19919 3d/compare-eax-and 0/imm32 -19920 0f 85/jump-if-!= $check-mu-compare-stmt:error-too-many-outputs/disp32 -19921 $check-mu-compare-stmt:get-left: -19922 # var left/edi: (addr stmt-var) = stmt->inouts -19923 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -19924 89/<- %edi 0/r32/eax -19925 # zero inouts -19926 3d/compare-eax-and 0/imm32 -19927 0f 84/jump-if-= $check-mu-compare-stmt:error-incorrect-inouts/disp32 -19928 $check-mu-compare-stmt:get-right: -19929 # var right/esi: (addr stmt-var) = left->next -19930 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -19931 89/<- %esi 0/r32/eax -19932 # 1 inout -19933 3d/compare-eax-and 0/imm32 -19934 0f 84/jump-if-= $check-mu-compare-stmt:error-incorrect-inouts/disp32 -19935 # > 2 inouts -19936 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -19937 3d/compare-eax-and 0/imm32 -19938 0f 85/jump-if-!= $check-mu-compare-stmt:error-incorrect-inouts/disp32 -19939 # if both inouts are in memory, abort -19940 { -19941 $check-mu-compare-stmt:both-in-mem: -19942 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19943 (lookup *(eax+0x8) *(eax+0xc)) # Var-type Var-type => eax -19944 (is-simple-mu-type? %eax 0) # => eax -19945 3d/compare-eax-and 0/imm32 -19946 0f 85/jump-if-!= break/disp32 -19947 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19948 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -19949 3d/compare-eax-and 0/imm32 -19950 75/jump-if-!= break/disp8 -19951 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19952 (lookup *(eax+0x8) *(eax+0xc)) # Var-type Var-type => eax -19953 (is-simple-mu-type? %eax 0) # => eax -19954 3d/compare-eax-and 0/imm32 -19955 75/jump-if-!= break/disp8 -19956 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19957 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -19958 3d/compare-eax-and 0/imm32 -19959 75/jump-if-!= break/disp8 -19960 e9/jump $check-mu-compare-stmt:error-both-in-memory/disp32 -19961 } -19962 $check-mu-compare-stmt:types: -19963 # var right-type/ecx: (addr type-tree) = right->value->type -19964 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19965 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19966 89/<- %ecx 0/r32/eax -19967 # if (right->is-deref?) right-type = right-type->payload -19968 8b/-> *(esi+0x10) 0/r32/eax # Stmt-var-is-deref -19969 3d/compare-eax-and 0/imm32/false -19970 { -19971 74/jump-if-= break/disp8 -19972 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -19973 # if right-type->right is null, right-type = right-type->left -19974 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -19975 { -19976 75/jump-if-!= break/disp8 -19977 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -19978 } -19979 89/<- %ecx 0/r32/eax -19980 } -19981 # if right is not a scalar, abort -19982 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -19983 (size-of %eax) # => eax -19984 3d/compare-eax-and 4/imm32 -19985 0f 8f/jump-if-> $check-mu-compare-stmt:error-right-too-large/disp32 -19986 # if left is not a scalar, abort -19987 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19988 (size-of %eax) # => eax -19989 3d/compare-eax-and 4/imm32 -19990 0f 8f/jump-if-> $check-mu-compare-stmt:error-left-too-large/disp32 -19991 # var left-type/ebx: (addr type-tree) = left->value->type -19992 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -19993 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -19994 89/<- %ebx 0/r32/eax -19995 # if (left->is-deref?) left-type = left-type->payload -19996 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref -19997 3d/compare-eax-and 0/imm32/false -19998 { -19999 74/jump-if-= break/disp8 -20000 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -20001 # if left-type->right is null, left-type = left-type->left -20002 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -20003 { -20004 75/jump-if-!= break/disp8 -20005 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20006 } -20007 89/<- %ebx 0/r32/eax -20008 } -20009 # if (left-type == right-type) return -20010 (type-match? %ebx %ecx %edx) # => eax -20011 3d/compare-eax-and 0/imm32 -20012 0f 85/jump-if-!= $check-mu-compare-stmt:end/disp32 -20013 # if left is an addr and right is 0, return -20014 { -20015 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20016 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -20017 (is-mu-addr-type? %eax) # => eax -20018 3d/compare-eax-and 0/imm32/false -20019 74/jump-if-= break/disp8 -20020 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -20021 (lookup *eax *(eax+4)) # Var-name Var-name => eax -20022 (string-equal? %eax "0") # => eax -20023 3d/compare-eax-and 0/imm32/false -20024 74/jump-if-= break/disp8 -20025 eb/jump $check-mu-compare-stmt:end/disp8 -20026 } -20027 # if left is not number-like, abort -20028 (check-mu-numberlike-arg %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -20029 $check-mu-compare-stmt:end: -20030 # . reclaim locals -20031 81 0/subop/add %esp 0x6c/imm32 -20032 # . restore registers -20033 5f/pop-to-edi -20034 5e/pop-to-esi -20035 5b/pop-to-ebx -20036 5a/pop-to-edx -20037 59/pop-to-ecx -20038 58/pop-to-eax -20039 # . epilogue -20040 89/<- %esp 5/r32/ebp -20041 5d/pop-to-ebp -20042 c3/return -20043 -20044 $check-mu-compare-stmt:error-incorrect-inouts: -20045 (write-buffered *(ebp+0x10) "fn ") -20046 8b/-> *(ebp+0xc) 0/r32/eax -20047 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20048 (write-buffered *(ebp+0x10) %eax) -20049 (write-buffered *(ebp+0x10) ": stmt 'compare' must have two inouts\n") -20050 (flush *(ebp+0x10)) -20051 (stop *(ebp+0x14) 1) -20052 # never gets here -20053 -20054 $check-mu-compare-stmt:error-too-many-outputs: -20055 (write-buffered *(ebp+0x10) "fn ") -20056 8b/-> *(ebp+0xc) 0/r32/eax -20057 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20058 (write-buffered *(ebp+0x10) %eax) -20059 (write-buffered *(ebp+0x10) ": stmt 'compare' must not have any outputs\n") -20060 (flush *(ebp+0x10)) -20061 (stop *(ebp+0x14) 1) -20062 # never gets here -20063 -20064 $check-mu-compare-stmt:error-both-in-memory: -20065 (write-buffered *(ebp+0x10) "fn ") -20066 8b/-> *(ebp+0xc) 0/r32/eax -20067 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20068 (write-buffered *(ebp+0x10) %eax) -20069 (write-buffered *(ebp+0x10) ": stmt compare: both inouts are in memory\n") -20070 (flush *(ebp+0x10)) -20071 (stop *(ebp+0x14) 1) -20072 # never gets here -20073 -20074 $check-mu-compare-stmt:error-left-too-large: -20075 (write-buffered *(ebp+0x10) "fn ") -20076 8b/-> *(ebp+0xc) 0/r32/eax -20077 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20078 (write-buffered *(ebp+0x10) %eax) -20079 (write-buffered *(ebp+0x10) ": stmt compare: '") -20080 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20081 (lookup *eax *(eax+4)) # Var-name Var-name => eax -20082 (write-buffered *(ebp+0x10) %eax) -20083 (write-buffered *(ebp+0x10) "' is too large to compare\n") -20084 (flush *(ebp+0x10)) -20085 (stop *(ebp+0x14) 1) -20086 # never gets here -20087 -20088 $check-mu-compare-stmt:error-right-too-large: -20089 (write-buffered *(ebp+0x10) "fn ") -20090 8b/-> *(ebp+0xc) 0/r32/eax -20091 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20092 (write-buffered *(ebp+0x10) %eax) -20093 (write-buffered *(ebp+0x10) ": stmt compare: '") -20094 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -20095 (lookup *eax *(eax+4)) # Var-name Var-name => eax -20096 (write-buffered *(ebp+0x10) %eax) -20097 (write-buffered *(ebp+0x10) "' is too large to compare\n") -20098 (flush *(ebp+0x10)) -20099 (stop *(ebp+0x14) 1) -20100 # never gets here -20101 -20102 check-mu-address-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -20103 # . prologue -20104 55/push-ebp -20105 89/<- %ebp 4/r32/esp -20106 # . save registers -20107 50/push-eax -20108 51/push-ecx -20109 52/push-edx -20110 56/push-esi -20111 57/push-edi -20112 $check-mu-address-stmt:get-output: -20113 # esi = stmt -20114 8b/-> *(ebp+8) 6/r32/esi -20115 # var output/edi: (addr stmt-var) = stmt->outputs -20116 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -20117 89/<- %edi 0/r32/eax -20118 # zero outputs -20119 3d/compare-eax-and 0/imm32 -20120 0f 84/jump-if-= $check-mu-address-stmt:error-no-output/disp32 -20121 # > 1 output -20122 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -20123 3d/compare-eax-and 0/imm32 -20124 0f 85/jump-if-!= $check-mu-address-stmt:error-too-many-outputs/disp32 -20125 $check-mu-address-stmt:get-inout: -20126 # var inout/esi: (addr stmt-var) = stmt->inouts -20127 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -20128 89/<- %esi 0/r32/eax -20129 # zero inouts -20130 3d/compare-eax-and 0/imm32 -20131 0f 84/jump-if-= $check-mu-address-stmt:error-no-inout/disp32 -20132 # > 1 inout -20133 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -20134 3d/compare-eax-and 0/imm32 -20135 0f 85/jump-if-!= $check-mu-address-stmt:error-too-many-inouts/disp32 -20136 $check-mu-address-stmt:types: -20137 # if output not in register, abort -20138 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20139 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -20140 3d/compare-eax-and 0/imm32 -20141 0f 84/jump-if-= $check-mu-address-stmt:error-output-not-in-register/disp32 -20142 # var output-type/edx: (addr type-tree) = output->value->type -20143 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20144 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -20145 89/<- %edx 0/r32/eax -20146 # if output-type not an addr, abort -20147 (is-mu-addr-type? %edx) # => eax -20148 3d/compare-eax-and 0/imm32/false -20149 0f 84/jump-if-= $check-mu-address-stmt:error-output-not-address/disp32 -20150 # output-type = output-type->right -20151 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax -20152 # if output-type->right is null, output-type = output-type->left -20153 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -20154 { -20155 75/jump-if-!= break/disp8 -20156 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20157 } -20158 89/<- %edx 0/r32/eax -20159 # var inout-type/ecx: (addr type-tree) = inout->value->type -20160 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -20161 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -20162 89/<- %ecx 0/r32/eax -20163 # if (inout->is-deref?) inout-type = inout-type->payload -20164 8b/-> *(esi+0x10) 0/r32/eax # Stmt-var-is-deref -20165 3d/compare-eax-and 0/imm32/false -20166 { -20167 74/jump-if-= break/disp8 -20168 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -20169 # if inout-type->right is null, t = inout-type->left -20170 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -20171 { -20172 75/jump-if-!= break/disp8 -20173 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20174 } -20175 89/<- %ecx 0/r32/eax -20176 } -20177 # if (inout-type != output-type) abort -20178 (type-equal-ignoring-capacity? %edx %ecx) # => eax -20179 3d/compare-eax-and 0/imm32 -20180 0f 84/jump-if-= $check-mu-address-stmt:error-type-mismatch/disp32 -20181 $check-mu-address-stmt:end: -20182 # . restore registers -20183 5f/pop-to-edi -20184 5e/pop-to-esi -20185 5a/pop-to-edx -20186 59/pop-to-ecx -20187 58/pop-to-eax -20188 # . epilogue -20189 89/<- %esp 5/r32/ebp -20190 5d/pop-to-ebp -20191 c3/return -20192 -20193 $check-mu-address-stmt:error-no-inout: -20194 (write-buffered *(ebp+0x10) "fn ") -20195 8b/-> *(ebp+0xc) 0/r32/eax -20196 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20197 (write-buffered *(ebp+0x10) %eax) -20198 (write-buffered *(ebp+0x10) ": stmt 'address' expects an inout\n") -20199 (flush *(ebp+0x10)) -20200 (stop *(ebp+0x14) 1) -20201 # never gets here -20202 -20203 $check-mu-address-stmt:error-too-many-inouts: -20204 (write-buffered *(ebp+0x10) "fn ") -20205 8b/-> *(ebp+0xc) 0/r32/eax -20206 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20207 (write-buffered *(ebp+0x10) %eax) -20208 (write-buffered *(ebp+0x10) ": stmt 'address' must have just one inout\n") -20209 (flush *(ebp+0x10)) -20210 (stop *(ebp+0x14) 1) -20211 # never gets here -20212 -20213 $check-mu-address-stmt:error-no-output: -20214 (write-buffered *(ebp+0x10) "fn ") -20215 8b/-> *(ebp+0xc) 0/r32/eax -20216 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20217 (write-buffered *(ebp+0x10) %eax) -20218 (write-buffered *(ebp+0x10) ": stmt 'address' expects an output\n") -20219 (flush *(ebp+0x10)) -20220 (stop *(ebp+0x14) 1) -20221 # never gets here -20222 -20223 $check-mu-address-stmt:error-output-not-in-register: -20224 (write-buffered *(ebp+0x10) "fn ") -20225 8b/-> *(ebp+0xc) 0/r32/eax -20226 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20227 (write-buffered *(ebp+0x10) %eax) -20228 (write-buffered *(ebp+0x10) ": stmt address: output '") -20229 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20230 (lookup *eax *(eax+4)) # Var-name Var-name => eax -20231 (write-buffered *(ebp+0x10) %eax) -20232 (write-buffered *(ebp+0x10) "' not in a register\n") -20233 (flush *(ebp+0x10)) -20234 (stop *(ebp+0x14) 1) -20235 # never gets here -20236 -20237 $check-mu-address-stmt:error-too-many-outputs: -20238 (write-buffered *(ebp+0x10) "fn ") -20239 8b/-> *(ebp+0xc) 0/r32/eax -20240 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20241 (write-buffered *(ebp+0x10) %eax) -20242 (write-buffered *(ebp+0x10) ": stmt 'address' must have just one output\n") -20243 (flush *(ebp+0x10)) -20244 (stop *(ebp+0x14) 1) -20245 # never gets here -20246 -20247 $check-mu-address-stmt:error-output-not-address: -20248 (write-buffered *(ebp+0x10) "fn ") -20249 8b/-> *(ebp+0xc) 0/r32/eax -20250 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20251 (write-buffered *(ebp+0x10) %eax) -20252 (write-buffered *(ebp+0x10) ": stmt address: output '") -20253 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20254 (lookup *eax *(eax+4)) # Var-name Var-name => eax -20255 (write-buffered *(ebp+0x10) %eax) -20256 (write-buffered *(ebp+0x10) "' is not an addr\n") -20257 (flush *(ebp+0x10)) -20258 (stop *(ebp+0x14) 1) -20259 # never gets here -20260 -20261 $check-mu-address-stmt:error-type-mismatch: -20262 (write-buffered *(ebp+0x10) "fn ") -20263 8b/-> *(ebp+0xc) 0/r32/eax -20264 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20265 (write-buffered *(ebp+0x10) %eax) -20266 (write-buffered *(ebp+0x10) ": stmt address: output '") -20267 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20268 (lookup *eax *(eax+4)) # Var-name Var-name => eax -20269 (write-buffered *(ebp+0x10) %eax) -20270 (write-buffered *(ebp+0x10) "' cannot hold address of '") -20271 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -20272 (lookup *eax *(eax+4)) # Var-name Var-name => eax -20273 (write-buffered *(ebp+0x10) %eax) -20274 (write-buffered *(ebp+0x10) "'\n") -20275 (flush *(ebp+0x10)) -20276 (stop *(ebp+0x14) 1) -20277 # never gets here -20278 -20279 type-equal-ignoring-capacity?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean -20280 # . prologue -20281 55/push-ebp -20282 89/<- %ebp 4/r32/esp -20283 # . save registers -20284 51/push-ecx -20285 52/push-edx -20286 53/push-ebx -20287 # var curr-a/ecx: (addr type-tree) = a -20288 8b/-> *(ebp+8) 1/r32/ecx -20289 # var curr-b/ebx: (addr type-tree) = b -20290 8b/-> *(ebp+0xc) 3/r32/ebx -20291 # if (curr-a->is-atom?) fall back to regular equality -20292 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -20293 0f 85/jump-if-!= $type-equal-ignoring-capacity?:base-case/disp32 -20294 # if (curr-a->left != curr-b->left) return false -20295 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -20296 89/<- %edx 0/r32/eax -20297 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -20298 (type-equal? %edx %eax) # => eax -20299 3d/compare-eax-and 0/imm32/false -20300 0f 84/jump-if-= $type-equal-ignoring-capacity?:end/disp32 # eax switches meaning -20301 # if (curr-a->left == "array") curr-a = curr-a->element-type -20302 { -20303 (is-mu-array? %edx) # => eax -20304 3d/compare-eax-and 0/imm32/false -20305 75/jump-if-!= break/disp8 -20306 $type-equal-ignoring-capacity?:array: -20307 # curr-a = curr-a->right->left -20308 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -20309 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20310 89/<- %ecx 0/r32/eax -20311 # curr-b = curr-b->right->left -20312 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -20313 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20314 89/<- %ebx 0/r32/eax -20315 eb/jump $type-equal-ignoring-capacity?:base-case/disp8 -20316 } -20317 # if (curr-a->left == "stream") curr-a = curr-a->element-type -20318 { -20319 (is-mu-stream? %edx) # => eax -20320 3d/compare-eax-and 0/imm32/false -20321 75/jump-if-!= break/disp8 -20322 $type-equal-ignoring-capacity?:stream: -20323 # curr-a = curr-a->right->left -20324 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -20325 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20326 89/<- %ecx 0/r32/eax -20327 # curr-b = curr-b->right->left -20328 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -20329 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20330 89/<- %ebx 0/r32/eax -20331 eb/jump $type-equal-ignoring-capacity?:base-case/disp8 -20332 } -20333 $type-equal-ignoring-capacity?:base-case: -20334 # return type-equal?(curr-a, curr-b) -20335 (type-equal? %ecx %ebx) # => eax -20336 $type-equal-ignoring-capacity?:end: -20337 # . restore registers -20338 5b/pop-to-ebx -20339 5a/pop-to-edx -20340 59/pop-to-ecx -20341 # . epilogue -20342 89/<- %esp 5/r32/ebp -20343 5d/pop-to-ebp -20344 c3/return -20345 -20346 check-mu-return-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -20347 # . prologue -20348 55/push-ebp -20349 89/<- %ebp 4/r32/esp -20350 # . save registers -20351 50/push-eax -20352 51/push-ecx -20353 52/push-edx -20354 53/push-ebx -20355 56/push-esi -20356 57/push-edi -20357 # var type-parameters/edx: (addr table (handle array byte) (addr type-tree) 8) -20358 81 5/subop/subtract %esp 0x60/imm32 -20359 68/push 0x60/imm32/size -20360 68/push 0/imm32/read -20361 68/push 0/imm32/write -20362 89/<- %edx 4/r32/esp -20363 # var template/esi: (addr list var) = fn->outputs -20364 8b/-> *(ebp+0xc) 0/r32/eax -20365 (lookup *(eax+0x10) *(eax+0x14)) # Function-outputs Function-outputs => eax -20366 89/<- %esi 0/r32/eax -20367 # var curr-template/ebx: (addr list var) = fn->outputs -20368 89/<- %ebx 0/r32/eax -20369 # var curr/edi: (addr stmt-var) = stmt->inouts -20370 8b/-> *(ebp+8) 0/r32/eax -20371 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax -20372 89/<- %edi 0/r32/eax -20373 { -20374 # if template is null, break -20375 81 7/subop/compare %ebx 0/imm32 -20376 0f 84/jump-if-= break/disp32 -20377 # if curr is null, abort -20378 81 7/subop/compare %edi 0/imm32 -20379 0f 84/jump-if-= $check-mu-return-stmt:error-too-few-inouts/disp32 -20380 # var template-type/ecx: (addr type-tree) = template->value->type -20381 (lookup *ebx *(ebx+4)) # List-value List-value => eax -20382 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -20383 89/<- %ecx 0/r32/eax -20384 # var curr-type/eax: (addr type-tree) = curr->value->type -20385 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20386 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -20387 # if (curr->is-deref?) curr-type = payload of curr-type -20388 81 7/subop/compare *(edi+0x10) 0/imm32/false # Stmt-var-is-deref -20389 { -20390 74/jump-if-= break/disp8 -20391 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -20392 # if t->right is null, t = t->left -20393 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -20394 75/jump-if-!= break/disp8 -20395 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20396 } -20397 # if (curr-type != template-type) abort -20398 (type-match? %ecx %eax %edx) # => eax -20399 3d/compare-eax-and 0/imm32/false -20400 0f 84/jump-if-= $check-mu-return-stmt:error1/disp32 -20401 # if register-within-list-with-conflict?(curr, original template, curr-template, stmt) abort -20402 (register-within-list-with-conflict? %edi %esi %ebx *(ebp+8)) # => eax -20403 3d/compare-eax-and 0/imm32/false -20404 0f 85/jump-if-!= $check-mu-return-stmt:error2/disp32 -20405 # template = template->next -20406 (lookup *(ebx+8) *(ebx+0xc)) # List-next List-next => eax -20407 89/<- %ebx 0/r32/eax -20408 # curr = curr->next -20409 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -20410 89/<- %edi 0/r32/eax -20411 # -20412 e9/jump loop/disp32 -20413 } -20414 # if curr is not null, abort -20415 81 7/subop/compare %edi 0/imm32 -20416 0f 85/jump-if-!= $check-mu-return-stmt:error-too-many-inouts/disp32 -20417 $check-mu-return-stmt:end: -20418 # . reclaim locals -20419 81 0/subop/add %esp 0x6c/imm32 -20420 # . restore registers -20421 5f/pop-to-edi -20422 5e/pop-to-esi -20423 5b/pop-to-ebx -20424 5a/pop-to-edx -20425 59/pop-to-ecx -20426 58/pop-to-eax -20427 # . epilogue -20428 89/<- %esp 5/r32/ebp -20429 5d/pop-to-ebp -20430 c3/return -20431 -20432 $check-mu-return-stmt:error1: -20433 (write-buffered *(ebp+0x10) "fn ") -20434 8b/-> *(ebp+0xc) 0/r32/eax -20435 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20436 (write-buffered *(ebp+0x10) %eax) -20437 (write-buffered *(ebp+0x10) ": return: '") -20438 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20439 (lookup *eax *(eax+4)) # Var-name Var-name => eax -20440 (write-buffered *(ebp+0x10) %eax) -20441 (write-buffered *(ebp+0x10) "' has the wrong type\n") -20442 (flush *(ebp+0x10)) -20443 (stop *(ebp+0x14) 1) -20444 # never gets here -20445 -20446 $check-mu-return-stmt:error2: -20447 (write-buffered *(ebp+0x10) "fn ") -20448 8b/-> *(ebp+0xc) 0/r32/eax -20449 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20450 (write-buffered *(ebp+0x10) %eax) -20451 (write-buffered *(ebp+0x10) ": return: '") -20452 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -20453 (lookup *eax *(eax+4)) # Var-name Var-name => eax -20454 (write-buffered *(ebp+0x10) %eax) -20455 (write-buffered *(ebp+0x10) "' is no longer available\n") -20456 (flush *(ebp+0x10)) -20457 (stop *(ebp+0x14) 1) -20458 # never gets here -20459 -20460 $check-mu-return-stmt:error-too-few-inouts: -20461 (write-buffered *(ebp+0x10) "fn ") -20462 8b/-> *(ebp+0xc) 0/r32/eax -20463 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20464 (write-buffered *(ebp+0x10) %eax) -20465 (write-buffered *(ebp+0x10) ": return: too few inouts\n") -20466 (flush *(ebp+0x10)) -20467 (stop *(ebp+0x14) 1) -20468 # never gets here -20469 -20470 $check-mu-return-stmt:error-too-many-inouts: -20471 (write-buffered *(ebp+0x10) "fn ") -20472 8b/-> *(ebp+0xc) 0/r32/eax -20473 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20474 (write-buffered *(ebp+0x10) %eax) -20475 (write-buffered *(ebp+0x10) ": return: too many inouts\n") -20476 (flush *(ebp+0x10)) -20477 (stop *(ebp+0x14) 1) -20478 # never gets here -20479 -20480 check-all-unique-registers: # outputs: (addr list var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -20481 # . prologue -20482 55/push-ebp -20483 89/<- %ebp 4/r32/esp -20484 # . save registers -20485 50/push-eax -20486 51/push-ecx -20487 56/push-esi -20488 # var table/esi: (addr table (handle array byte) int 8) -20489 81 5/subop/subtract %esp 0x60/imm32 -20490 68/push 0x60/imm32/size -20491 68/push 0/imm32/read -20492 68/push 0/imm32/write -20493 89/<- %esi 4/r32/esp -20494 # var curr/ecx: (addr list var) = outputs -20495 8b/-> *(ebp+8) 1/r32/ecx -20496 { -20497 # if (curr == 0) break -20498 81 7/subop/compare %ecx 0/imm32 -20499 0f 84/jump-if-= break/disp32 -20500 # var reg/eax: (addr array byte) = curr->value->register # guaranteed to exist -20501 (lookup *ecx *(ecx+4)) # List-value List-value => eax -20502 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -20503 # if reg exists in table, abort -20504 (maybe-get %esi %eax 0xc) # => eax -20505 3d/compare-eax-and 0/imm32 -20506 0f 85/jump-if-!= $check-all-unique-registers:abort/disp32 -20507 # insert reg in table -20508 (lookup *ecx *(ecx+4)) # List-value List-value => eax -20509 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -20510 (get-or-insert %esi %eax 0xc Heap) -20511 # curr = curr->next -20512 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -20513 89/<- %ecx 0/r32/eax -20514 e9/jump loop/disp32 -20515 } -20516 $check-all-unique-registers:end: -20517 # . reclaim locals -20518 81 0/subop/add %esp 0x6c/imm32 -20519 # . restore registers -20520 5e/pop-to-esi -20521 59/pop-to-ecx -20522 58/pop-to-eax -20523 # . epilogue -20524 89/<- %esp 5/r32/ebp -20525 5d/pop-to-ebp -20526 c3/return -20527 -20528 $check-all-unique-registers:abort: -20529 (write-buffered *(ebp+0x10) "fn ") -20530 8b/-> *(ebp+0xc) 0/r32/eax -20531 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20532 (write-buffered *(ebp+0x10) %eax) -20533 (write-buffered *(ebp+0x10) ": outputs must be in unique registers\n") -20534 (flush *(ebp+0x10)) -20535 (stop *(ebp+0x14) 1) -20536 # never gets here -20537 -20538 # return false if s's register is not between start (inclusive) and end (exclusive) -20539 # return false if the positionally corresponding register in stmt->inouts (where s comes from) is also s's register -20540 # otherwise return true -20541 register-within-list-with-conflict?: # s: (addr stmt-var), start: (addr list var), end: (addr list var), stmt: (addr stmt) -> result/eax: boolean -20542 # . prologue -20543 55/push-ebp -20544 89/<- %ebp 4/r32/esp -20545 # . save registers -20546 51/push-ecx -20547 52/push-edx -20548 53/push-ebx -20549 56/push-esi -20550 57/push-edi -20551 # var target/ebx: (addr array byte) = s->value->register -20552 8b/-> *(ebp+8) 0/r32/eax -20553 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -20554 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -20555 #? (write-buffered Stderr "AA: ") -20556 #? (write-buffered Stderr %eax) -20557 #? (write-buffered Stderr Newline) -20558 #? (flush Stderr) -20559 # if (var->register == 0) return false -20560 3d/compare-eax-and 0/imm32 -20561 0f 84/jump-if-= $register-within-list-with-conflict?:end/disp32 # eax turns into result -20562 89/<- %ebx 0/r32/eax -20563 # var curr/ecx: (addr list var) = start -20564 8b/-> *(ebp+0xc) 1/r32/ecx -20565 # edx = end -20566 8b/-> *(ebp+0x10) 2/r32/edx -20567 { -20568 # if (curr == 0) break -20569 81 7/subop/compare %edi 0/imm32 -20570 0f 84/jump-if-= break/disp32 -20571 # if (curr == end) break -20572 39/compare %ecx 2/r32/edx -20573 0f 84/jump-if-= break/disp32 -20574 # var curr-reg/eax: (addr array byte) = curr->value->register -20575 (lookup *ecx *(ecx+4)) # List-value List-value => eax -20576 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -20577 # if (curr-reg == 0) continue -20578 3d/compare-eax-and 0/imm32 -20579 74/jump-if-= $register-within-list-with-conflict?:continue/disp8 -20580 # if (curr-reg == target) check for conflict -20581 (string-equal? %eax %ebx) # => eax -20582 3d/compare-eax-and 0/imm32/false -20583 { -20584 74/jump-if-= break/disp8 -20585 #? (write-buffered Stderr "conflict?\n") -20586 #? (flush Stderr) -20587 # var return-inouts/eax: (addr stmt-var) = stmt->inouts -20588 8b/-> *(ebp+0x14) 0/r32/eax -20589 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax -20590 (register-conflict? %ebx %eax *(ebp+0xc)) # => eax -20591 eb/jump $register-within-list-with-conflict?:end/disp8 -20592 } -20593 $register-within-list-with-conflict?:continue: -20594 # curr = curr->next -20595 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -20596 89/<- %ecx 0/r32/eax -20597 e9/jump loop/disp32 -20598 } -20599 # return false -20600 b8/copy-to-eax 0/imm32/false -20601 $register-within-list-with-conflict?:end: -20602 # . restore registers -20603 5f/pop-to-edi -20604 5e/pop-to-esi -20605 5b/pop-to-ebx -20606 5a/pop-to-edx -20607 59/pop-to-ecx -20608 # . epilogue -20609 89/<- %esp 5/r32/ebp -20610 5d/pop-to-ebp -20611 c3/return -20612 -20613 # At the first occurrence of register 'reg' in fn-outputs, -20614 # check if the corresponding element of return-inouts has a different register. -20615 # This hacky helper is intended to be called in one specific place. Don't -20616 # reuse it as is. -20617 register-conflict?: # reg: (addr array byte), return-inouts: (addr stmt-var), fn-outputs: (addr list var) => result/eax: boolean -20618 # . prologue -20619 55/push-ebp -20620 89/<- %ebp 4/r32/esp -20621 # . save registers -20622 51/push-ecx -20623 52/push-edx -20624 53/push-ebx -20625 56/push-esi -20626 57/push-edi -20627 #? (write-buffered Stderr "BB: ") -20628 #? (write-buffered Stderr *(ebp+8)) -20629 #? (write-buffered Stderr Newline) -20630 #? (flush Stderr) -20631 # var curr-output/edi: (addr list var) = fn-outputs -20632 8b/-> *(ebp+0x10) 7/r32/edi -20633 # var curr-inout/esi: (addr stmt-var) = return-inouts -20634 8b/-> *(ebp+0xc) 6/r32/esi -20635 { -20636 # if (curr-output == 0) abort -20637 81 7/subop/compare %edi 0/imm32 -20638 0f 84/jump-if-= break/disp32 -20639 # if (curr-output->value->register != reg) continue -20640 (lookup *edi *(edi+4)) # List-value List-value => eax -20641 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -20642 (string-equal? %eax *(ebp+8)) # => eax -20643 3d/compare-eax-and 0/imm32/false -20644 0f 84/jump-if= $register-conflict?:continue/disp32 -20645 #? (write-buffered Stderr "rescan\n") -20646 #? (flush Stderr) -20647 # var curr-reg/eax: (addr array byte) = curr-inout->value->register -20648 (lookup *esi *(esi+4)) # List-value List-value => eax -20649 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -20650 # if (curr-reg == 0) return true -20651 3d/compare-eax-and 0/imm32 -20652 { -20653 75/jump-if-!= break/disp8 -20654 #? (write-buffered Stderr "no register\n") -20655 #? (flush Stderr) -20656 b8/copy-to-eax 1/imm32/true -20657 e9/jump $register-conflict?:end/disp32 -20658 } -20659 # return (curr-reg != reg) -20660 (string-equal? %eax *(ebp+8)) # => eax -20661 3d/compare-eax-and 0/imm32/false -20662 0f 94/set-if-= %al -20663 #? (write-buffered Stderr "final: ") -20664 #? (write-int32-hex-buffered Stderr %eax) -20665 #? (write-buffered Stderr Newline) -20666 #? (flush Stderr) -20667 eb/jump $register-conflict?:end/disp8 -20668 $register-conflict?:continue: -20669 # curr-output = curr-output->next -20670 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax -20671 89/<- %edi 0/r32/eax -20672 # curr-inout = curr-inout->next -20673 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -20674 89/<- %esi 0/r32/eax -20675 e9/jump loop/disp32 -20676 } -20677 # should never get here -20678 (write-buffered Stderr "register-conflict? misused\n") -20679 (flush Stderr) -20680 e8/call syscall_exit/disp32 -20681 $register-conflict?:end: -20682 # . restore registers -20683 5f/pop-to-edi -20684 5e/pop-to-esi -20685 5b/pop-to-ebx -20686 5a/pop-to-edx -20687 59/pop-to-ecx -20688 # . epilogue -20689 89/<- %esp 5/r32/ebp -20690 5d/pop-to-ebp -20691 c3/return -20692 -20693 check-final-stmt-is-return: # block: (addr block), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -20694 # . prologue -20695 55/push-ebp -20696 89/<- %ebp 4/r32/esp -20697 # . save registers -20698 50/push-eax -20699 51/push-ecx -20700 # var curr/ecx: (addr list stmt) = block->stmts -20701 8b/-> *(ebp+8) 0/r32/eax -20702 (lookup *(eax+4) *(eax+8)) # Block-stmts Block-stmts => eax -20703 3d/compare-eax-and 0/imm32 -20704 74/jump-if-= $check-final-stmt-is-return:end/disp8 -20705 89/<- %ecx 0/r32/eax -20706 { -20707 # if curr->next == 0, break -20708 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -20709 3d/compare-eax-and 0/imm32 -20710 74/jump-if-= break/disp8 -20711 # curr = curr->next -20712 89/<- %ecx 0/r32/eax -20713 e9/jump loop/disp32 +19920 { +19921 74/jump-if-= break/disp8 +19922 (check-mu-call *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +19923 eb/jump $check-mu-stmt:end/disp8 +19924 } +19925 # - otherwise abort +19926 e9/jump $check-mu-stmt:unknown-call/disp32 +19927 $check-mu-stmt:end: +19928 # . restore registers +19929 58/pop-to-eax +19930 # . epilogue +19931 89/<- %esp 5/r32/ebp +19932 5d/pop-to-ebp +19933 c3/return +19934 +19935 $check-mu-stmt:unknown-call: +19936 (write-buffered *(ebp+0x10) "unknown function '") +19937 8b/-> *(ebp+8) 0/r32/eax +19938 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +19939 (write-buffered *(ebp+0x10) %eax) +19940 (write-buffered *(ebp+0x10) "'\n") +19941 (flush *(ebp+0x10)) +19942 (stop *(ebp+0x14) 1) +19943 # never gets here +19944 +19945 has-primitive-name?: # stmt: (addr stmt) -> result/eax: boolean +19946 # . prologue +19947 55/push-ebp +19948 89/<- %ebp 4/r32/esp +19949 # . save registers +19950 51/push-ecx +19951 56/push-esi +19952 # var name/esi: (addr array byte) = lookup(stmt->operation) +19953 8b/-> *(ebp+8) 6/r32/esi +19954 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax +19955 89/<- %esi 0/r32/eax +19956 # if (name == "return") return true +19957 (string-equal? %esi "return") # => eax +19958 3d/compare-eax-and 0/imm32/false +19959 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19960 # if (name == "get") return true +19961 (string-equal? %esi "get") # => eax +19962 3d/compare-eax-and 0/imm32/false +19963 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19964 # if (name == "index") return true +19965 (string-equal? %esi "index") # => eax +19966 3d/compare-eax-and 0/imm32/false +19967 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19968 # if (name == "length") return true +19969 (string-equal? %esi "length") # => eax +19970 3d/compare-eax-and 0/imm32/false +19971 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19972 # if (name == "compute-offset") return true +19973 (string-equal? %esi "compute-offset") # => eax +19974 3d/compare-eax-and 0/imm32/false +19975 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19976 # if (name == "copy-object") return true +19977 (string-equal? %esi "copy-object") # => eax +19978 3d/compare-eax-and 0/imm32/false +19979 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19980 # if (name == "clear-object") return true +19981 (string-equal? %esi "clear-object") # => eax +19982 3d/compare-eax-and 0/imm32/false +19983 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19984 # if (name == "allocate") return true +19985 (string-equal? %esi "allocate") # => eax +19986 3d/compare-eax-and 0/imm32/false +19987 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19988 # if (name == "populate") return true +19989 (string-equal? %esi "populate") # => eax +19990 3d/compare-eax-and 0/imm32/false +19991 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19992 # if (name == "populate-stream") return true +19993 (string-equal? %esi "populate-stream") # => eax +19994 3d/compare-eax-and 0/imm32/false +19995 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +19996 # if (name == "read-from-stream") return true +19997 (string-equal? %esi "read-from-stream") # => eax +19998 3d/compare-eax-and 0/imm32/false +19999 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +20000 # if (name == "write-to-stream") return true +20001 (string-equal? %esi "write-to-stream") # => eax +20002 3d/compare-eax-and 0/imm32/false +20003 0f 85/jump-if-!= $has-primitive-name?:end/disp32 +20004 # var curr/ecx: (addr primitive) = Primitives +20005 b9/copy-to-ecx Primitives/imm32 +20006 { +20007 $has-primitive-name?:loop: +20008 # if (curr == null) break +20009 81 7/subop/compare %ecx 0/imm32 +20010 74/jump-if-= break/disp8 +20011 # if (primitive->name == name) return true +20012 (lookup *ecx *(ecx+4)) # Primitive-name Primitive-name => eax +20013 #? (write-buffered Stderr %eax) +20014 #? (write-buffered Stderr Newline) +20015 #? (flush Stderr) +20016 (string-equal? %esi %eax) # => eax +20017 3d/compare-eax-and 0/imm32/false +20018 75/jump-if-!= $has-primitive-name?:end/disp8 +20019 $has-primitive-name?:next-primitive: +20020 # curr = curr->next +20021 (lookup *(ecx+0x3c) *(ecx+0x40)) # Primitive-next Primitive-next => eax +20022 89/<- %ecx 0/r32/eax +20023 # +20024 e9/jump loop/disp32 +20025 } +20026 # return null +20027 b8/copy-to-eax 0/imm32 +20028 $has-primitive-name?:end: +20029 # . restore registers +20030 5e/pop-to-esi +20031 59/pop-to-ecx +20032 # . epilogue +20033 89/<- %esp 5/r32/ebp +20034 5d/pop-to-ebp +20035 c3/return +20036 +20037 check-mu-primitive: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +20038 # . prologue +20039 55/push-ebp +20040 89/<- %ebp 4/r32/esp +20041 # . save registers +20042 50/push-eax +20043 51/push-ecx +20044 # var op/ecx: (addr array byte) = lookup(stmt->operation) +20045 8b/-> *(ebp+8) 0/r32/eax +20046 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +20047 89/<- %ecx 0/r32/eax +20048 # if (op == "copy") check-mu-copy-stmt +20049 { +20050 (string-equal? %ecx "copy") # => eax +20051 3d/compare-eax-and 0/imm32/false +20052 74/jump-if-= break/disp8 +20053 (check-mu-copy-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20054 e9/jump $check-mu-primitive:end/disp32 +20055 } +20056 # if (op == "copy-to") check-mu-copy-to-stmt +20057 { +20058 (string-equal? %ecx "copy-to") # => eax +20059 3d/compare-eax-and 0/imm32/false +20060 74/jump-if-= break/disp8 +20061 (check-mu-copy-to-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20062 e9/jump $check-mu-primitive:end/disp32 +20063 } +20064 # if (op == "compare") check-mu-compare-stmt +20065 { +20066 (string-equal? %ecx "compare") # => eax +20067 3d/compare-eax-and 0/imm32/false +20068 74/jump-if-= break/disp8 +20069 (check-mu-compare-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20070 e9/jump $check-mu-primitive:end/disp32 +20071 } +20072 # if (op == "address") check-mu-address-stmt +20073 { +20074 (string-equal? %ecx "address") # => eax +20075 3d/compare-eax-and 0/imm32/false +20076 74/jump-if-= break/disp8 +20077 (check-mu-address-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20078 e9/jump $check-mu-primitive:end/disp32 +20079 } +20080 # if (op == "return") check-mu-return-stmt +20081 { +20082 (string-equal? %ecx "return") # => eax +20083 3d/compare-eax-and 0/imm32/false +20084 74/jump-if-= break/disp8 +20085 (check-mu-return-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20086 e9/jump $check-mu-primitive:end/disp32 +20087 } +20088 # if (op == "get") check-mu-get-stmt +20089 { +20090 (string-equal? %ecx "get") # => eax +20091 3d/compare-eax-and 0/imm32/false +20092 74/jump-if-= break/disp8 +20093 (check-mu-get-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20094 e9/jump $check-mu-primitive:end/disp32 +20095 } +20096 # if (op == "index") check-mu-index-stmt +20097 { +20098 (string-equal? %ecx "index") # => eax +20099 3d/compare-eax-and 0/imm32/false +20100 74/jump-if-= break/disp8 +20101 (check-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20102 e9/jump $check-mu-primitive:end/disp32 +20103 } +20104 # if (op == "length") check-mu-length-stmt +20105 { +20106 (string-equal? %ecx "length") # => eax +20107 3d/compare-eax-and 0/imm32/false +20108 74/jump-if-= break/disp8 +20109 (check-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20110 e9/jump $check-mu-primitive:end/disp32 +20111 } +20112 # if (op == "compute-offset") check-mu-compute-offset-stmt +20113 { +20114 (string-equal? %ecx "compute-offset") # => eax +20115 3d/compare-eax-and 0/imm32/false +20116 74/jump-if-= break/disp8 +20117 (check-mu-compute-offset-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20118 e9/jump $check-mu-primitive:end/disp32 +20119 } +20120 # if (op == "copy-object") check-mu-copy-object-stmt +20121 { +20122 (string-equal? %ecx "copy-object") # => eax +20123 3d/compare-eax-and 0/imm32/false +20124 74/jump-if-= break/disp8 +20125 (check-mu-copy-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20126 e9/jump $check-mu-primitive:end/disp32 +20127 } +20128 # if (op == "clear-object") check-mu-clear-object-stmt +20129 { +20130 (string-equal? %ecx "clear-object") # => eax +20131 3d/compare-eax-and 0/imm32/false +20132 74/jump-if-= break/disp8 +20133 (check-mu-clear-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20134 e9/jump $check-mu-primitive:end/disp32 +20135 } +20136 # if (op == "allocate") check-mu-allocate-stmt +20137 { +20138 (string-equal? %ecx "allocate") # => eax +20139 3d/compare-eax-and 0/imm32/false +20140 74/jump-if-= break/disp8 +20141 (check-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20142 e9/jump $check-mu-primitive:end/disp32 +20143 } +20144 # if (op == "populate") check-mu-populate-stmt +20145 { +20146 (string-equal? %ecx "populate") # => eax +20147 3d/compare-eax-and 0/imm32/false +20148 74/jump-if-= break/disp8 +20149 (check-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20150 e9/jump $check-mu-primitive:end/disp32 +20151 } +20152 # if (op == "populate-stream") check-mu-populate-stream-stmt +20153 { +20154 (string-equal? %ecx "populate-stream") # => eax +20155 3d/compare-eax-and 0/imm32/false +20156 74/jump-if-= break/disp8 +20157 (check-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20158 e9/jump $check-mu-primitive:end/disp32 +20159 } +20160 # if (op == "read-from-stream") check-mu-read-from-stream-stmt +20161 { +20162 (string-equal? %ecx "read-from-stream") # => eax +20163 3d/compare-eax-and 0/imm32/false +20164 74/jump-if-= break/disp8 +20165 (check-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20166 e9/jump $check-mu-primitive:end/disp32 +20167 } +20168 # if (op == "write-to-stream") check-mu-write-to-stream-stmt +20169 { +20170 (string-equal? %ecx "write-to-stream") # => eax +20171 3d/compare-eax-and 0/imm32/false +20172 74/jump-if-= break/disp8 +20173 (check-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20174 e9/jump $check-mu-primitive:end/disp32 +20175 } +20176 # if (op == "convert") check-mu-convert-stmt +20177 { +20178 (string-equal? %ecx "convert") # => eax +20179 3d/compare-eax-and 0/imm32/false +20180 74/jump-if-= break/disp8 +20181 (check-mu-convert-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20182 e9/jump $check-mu-primitive:end/disp32 +20183 } +20184 # otherwise check-numberlike-stmt +20185 (check-mu-numberlike-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20186 $check-mu-primitive:end: +20187 # . restore registers +20188 59/pop-to-ecx +20189 58/pop-to-eax +20190 # . epilogue +20191 89/<- %esp 5/r32/ebp +20192 5d/pop-to-ebp +20193 c3/return +20194 +20195 # by default, Mu primitives should only operate on 'number-like' types +20196 check-mu-numberlike-primitive: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +20197 # . prologue +20198 55/push-ebp +20199 89/<- %ebp 4/r32/esp +20200 # . save registers +20201 50/push-eax +20202 51/push-ecx +20203 56/push-esi +20204 # esi = stmt +20205 8b/-> *(ebp+8) 6/r32/esi +20206 # var gas/ecx: int = 2 +20207 b9/copy-to-ecx 2/imm32 +20208 # - check at most 1 output +20209 # var output/eax: (addr stmt-var) = stmt->outputs +20210 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +20211 { +20212 3d/compare-eax-and 0/imm32 +20213 74/jump-if-= break/disp8 +20214 $check-mu-numberlike-primitive:output: +20215 (check-mu-numberlike-output %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20216 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +20217 3d/compare-eax-and 0/imm32 +20218 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-outputs/disp32 +20219 # check output is in a register +20220 # --gas +20221 49/decrement-ecx +20222 } +20223 # - check first inout +20224 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +20225 { +20226 3d/compare-eax-and 0/imm32 +20227 0f 84/jump-if-= $check-mu-numberlike-primitive:end/disp32 +20228 $check-mu-numberlike-primitive:first-inout: +20229 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20230 # --gas +20231 49/decrement-ecx +20232 } +20233 # - check second inout +20234 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +20235 { +20236 3d/compare-eax-and 0/imm32 +20237 74/jump-if-= $check-mu-numberlike-primitive:end/disp8 +20238 $check-mu-numberlike-primitive:second-inout: +20239 # is a second inout allowed? +20240 81 7/subop/compare %ecx 0/imm32 +20241 0f 84/jump-if-= $check-mu-numberlike-primitive:error-too-many-inouts/disp32 +20242 $check-mu-numberlike-primitive:second-inout-permitted: +20243 (check-mu-numberlike-arg %eax *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20244 } +20245 $check-mu-numberlike-primitive:third-inout: +20246 # if there's a third arg, raise an error +20247 81 7/subop/compare *(eax+8) 0/imm32 # Stmt-var-next +20248 0f 85/jump-if-!= $check-mu-numberlike-primitive:error-too-many-inouts/disp32 +20249 $check-mu-numberlike-primitive:end: +20250 # . restore registers +20251 5e/pop-to-esi +20252 59/pop-to-ecx +20253 58/pop-to-eax +20254 # . epilogue +20255 89/<- %esp 5/r32/ebp +20256 5d/pop-to-ebp +20257 c3/return +20258 +20259 $check-mu-numberlike-primitive:error-too-many-inouts: +20260 (write-buffered *(ebp+0x10) "fn ") +20261 8b/-> *(ebp+0xc) 0/r32/eax +20262 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20263 (write-buffered *(ebp+0x10) %eax) +20264 (write-buffered *(ebp+0x10) ": stmt ") +20265 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax +20266 (write-buffered *(ebp+0x10) %eax) +20267 (write-buffered *(ebp+0x10) ": too many inouts; most primitives support at most two arguments, across inouts and outputs\n") +20268 (flush *(ebp+0x10)) +20269 (stop *(ebp+0x14) 1) +20270 # never gets here +20271 +20272 $check-mu-numberlike-primitive:error-too-many-outputs: +20273 (write-buffered *(ebp+0x10) "fn ") +20274 8b/-> *(ebp+0xc) 0/r32/eax +20275 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20276 (write-buffered *(ebp+0x10) %eax) +20277 (write-buffered *(ebp+0x10) ": stmt ") +20278 (lookup *(esi+4) *(esi+8)) # Stmt1-operation Stmt1-operation => eax +20279 (write-buffered *(ebp+0x10) %eax) +20280 (write-buffered *(ebp+0x10) ": too many outputs; most primitives support at most one output\n") +20281 (flush *(ebp+0x10)) +20282 (stop *(ebp+0x14) 1) +20283 # never gets here +20284 +20285 check-mu-numberlike-arg: # v: (addr stmt-var), stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +20286 # . prologue +20287 55/push-ebp +20288 89/<- %ebp 4/r32/esp +20289 # . save registers +20290 50/push-eax +20291 56/push-esi +20292 # var t/esi: (addr type-tree) = lookup(v->value->type) +20293 8b/-> *(ebp+8) 0/r32/eax +20294 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +20295 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20296 89/<- %esi 0/r32/eax +20297 $check-mu-numberlike-arg:check-literal: +20298 # if t is an int, return +20299 (is-simple-mu-type? %esi 0) # literal => eax +20300 3d/compare-eax-and 0/imm32/false +20301 0f 85/jump-if-!= $check-mu-numberlike-arg:end/disp32 +20302 $check-mu-numberlike-arg:check-addr: +20303 # if t is an addr and v is dereferenced, return whether t->payload is an addr +20304 { +20305 (is-mu-addr-type? %esi) # => eax +20306 3d/compare-eax-and 0/imm32/false +20307 74/jump-if-= break/disp8 +20308 8b/-> *(ebp+8) 0/r32/eax +20309 8b/-> *(eax+0x10) 0/r32/eax # Stmt-var-is-deref +20310 3d/compare-eax-and 0/imm32/false +20311 { +20312 74/jump-if-= break/disp8 +20313 (lookup *(esi+0xc) *(esi+0x10)) # Type-tree-right Type-tree-right => eax +20314 # if t->right is null, t = t->left +20315 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +20316 { +20317 75/jump-if-!= break/disp8 +20318 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +20319 } +20320 (is-mu-addr-type? %eax) # => eax +20321 3d/compare-eax-and 0/imm32/false +20322 74/jump-if-= $check-mu-numberlike-arg:end/disp8 +20323 } +20324 } +20325 $check-mu-numberlike-arg:output-checks: +20326 (check-mu-numberlike-output *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14) *(ebp+0x18)) +20327 $check-mu-numberlike-arg:end: +20328 # . restore registers +20329 5e/pop-to-esi +20330 58/pop-to-eax +20331 # . epilogue +20332 89/<- %esp 5/r32/ebp +20333 5d/pop-to-ebp +20334 c3/return +20335 +20336 check-mu-numberlike-output: # v: (addr stmt-var), stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +20337 # . prologue +20338 55/push-ebp +20339 89/<- %ebp 4/r32/esp +20340 # . save registers +20341 50/push-eax +20342 # +20343 (is-mu-numberlike-output-var? *(ebp+8)) # => eax +20344 3d/compare-eax-and 0/imm32/false +20345 0f 84/jump-if-= $check-mu-numberlike-output:fail/disp32 +20346 $check-mu-numberlike-output:end: +20347 # . restore registers +20348 58/pop-to-eax +20349 # . epilogue +20350 89/<- %esp 5/r32/ebp +20351 5d/pop-to-ebp +20352 c3/return +20353 +20354 $check-mu-numberlike-output:fail: +20355 # otherwise raise an error +20356 (write-buffered *(ebp+0x14) "fn ") +20357 8b/-> *(ebp+0x10) 0/r32/eax +20358 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20359 (write-buffered *(ebp+0x14) %eax) +20360 (write-buffered *(ebp+0x14) ": stmt ") +20361 8b/-> *(ebp+0xc) 0/r32/eax +20362 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +20363 (write-buffered *(ebp+0x14) %eax) +20364 (write-buffered *(ebp+0x14) ": '") +20365 8b/-> *(ebp+8) 0/r32/eax +20366 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +20367 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20368 (write-buffered *(ebp+0x14) %eax) +20369 (write-buffered *(ebp+0x14) "' must be a non-addr non-offset scalar\n") +20370 (flush *(ebp+0x14)) +20371 (stop *(ebp+0x18) 1) +20372 # never gets here +20373 +20374 is-mu-numberlike-output-var?: # v: (addr stmt-var) -> result/eax: boolean +20375 # . prologue +20376 55/push-ebp +20377 89/<- %ebp 4/r32/esp +20378 # +20379 8b/-> *(ebp+8) 0/r32/eax +20380 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +20381 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20382 (is-mu-numberlike-output? %eax) # => eax +20383 $is-mu-numberlike-output-var?:end: +20384 # . epilogue +20385 89/<- %esp 5/r32/ebp +20386 5d/pop-to-ebp +20387 c3/return +20388 +20389 is-mu-numberlike-output?: # v: (addr type-tree) -> result/eax: boolean +20390 # . prologue +20391 55/push-ebp +20392 89/<- %ebp 4/r32/esp +20393 # . save registers +20394 56/push-esi +20395 # var t/esi: (addr type-tree) = lookup(v->value->type) +20396 8b/-> *(ebp+8) 6/r32/esi +20397 $is-mu-numberlike-output?:check-int: +20398 # if t is an int, return +20399 (is-simple-mu-type? %esi 1) # int => eax +20400 3d/compare-eax-and 0/imm32/false +20401 0f 85/jump-if-!= $is-mu-numberlike-output?:return-true/disp32 +20402 $is-mu-numberlike-output?:check-float: +20403 # if t is a float, return +20404 (is-simple-mu-type? %esi 0xf) # float => eax +20405 3d/compare-eax-and 0/imm32/false +20406 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 +20407 $is-mu-numberlike-output?:check-boolean: +20408 # if t is a boolean, return +20409 (is-simple-mu-type? %esi 5) # boolean => eax +20410 3d/compare-eax-and 0/imm32/false +20411 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 +20412 $is-mu-numberlike-output?:check-byte: +20413 # if t is a byte, return +20414 (is-simple-mu-type? %esi 8) # byte => eax +20415 3d/compare-eax-and 0/imm32/false +20416 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 +20417 $is-mu-numberlike-output?:check-code-point: +20418 # if t is a code-point, return +20419 (is-simple-mu-type? %esi 0xd) # code-point => eax +20420 3d/compare-eax-and 0/imm32/false +20421 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 +20422 $is-mu-numberlike-output?:check-grapheme: +20423 # if t is a grapheme, return +20424 (is-simple-mu-type? %esi 0xe) # grapheme => eax +20425 3d/compare-eax-and 0/imm32/false +20426 75/jump-if-!= $is-mu-numberlike-output?:return-true/disp8 +20427 $is-mu-numberlike-output?:return-false: +20428 b8/copy-to-eax 0/imm32/false +20429 eb/jump $is-mu-numberlike-output?:end/disp8 +20430 $is-mu-numberlike-output?:return-true: +20431 b8/copy-to-eax 1/imm32/true +20432 $is-mu-numberlike-output?:end: +20433 # . restore registers +20434 5e/pop-to-esi +20435 # . epilogue +20436 89/<- %esp 5/r32/ebp +20437 5d/pop-to-ebp +20438 c3/return +20439 +20440 check-mu-copy-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +20441 # . prologue +20442 55/push-ebp +20443 89/<- %ebp 4/r32/esp +20444 # . save registers +20445 50/push-eax +20446 51/push-ecx +20447 52/push-edx +20448 56/push-esi +20449 57/push-edi +20450 # var type-parameters/edx: (addr table (handle array byte) (addr type-tree) 8) +20451 81 5/subop/subtract %esp 0x60/imm32 +20452 68/push 0x60/imm32/size +20453 68/push 0/imm32/read +20454 68/push 0/imm32/write +20455 89/<- %edx 4/r32/esp +20456 $check-mu-copy-stmt:get-output: +20457 # esi = stmt +20458 8b/-> *(ebp+8) 6/r32/esi +20459 # var output/edi: (addr stmt-var) = stmt->outputs +20460 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +20461 89/<- %edi 0/r32/eax +20462 # zero outputs +20463 3d/compare-eax-and 0/imm32 +20464 0f 84/jump-if-= $check-mu-copy-stmt:error-no-output/disp32 +20465 # > 1 output +20466 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +20467 3d/compare-eax-and 0/imm32 +20468 0f 85/jump-if-!= $check-mu-copy-stmt:error-too-many-outputs/disp32 +20469 $check-mu-copy-stmt:get-inout: +20470 # var inout/esi: (addr stmt-var) = stmt->inouts +20471 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +20472 89/<- %esi 0/r32/eax +20473 # zero inouts +20474 3d/compare-eax-and 0/imm32 +20475 0f 84/jump-if-= $check-mu-copy-stmt:error-no-inout/disp32 +20476 # > 1 inout +20477 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +20478 3d/compare-eax-and 0/imm32 +20479 0f 85/jump-if-!= $check-mu-copy-stmt:error-too-many-inouts/disp32 +20480 $check-mu-copy-stmt:types: +20481 # var inout-type/ecx: (addr type-tree) = inout->value->type +20482 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20483 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20484 89/<- %ecx 0/r32/eax +20485 # if (inout->is-deref?) inout-type = inout-type->payload +20486 8b/-> *(esi+0x10) 0/r32/eax # Stmt-var-is-deref +20487 3d/compare-eax-and 0/imm32/false +20488 { +20489 74/jump-if-= break/disp8 +20490 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +20491 # if inout-type->right is null, t = inout-type->left +20492 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +20493 { +20494 75/jump-if-!= break/disp8 +20495 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +20496 } +20497 89/<- %ecx 0/r32/eax +20498 } +20499 # if output not in register, abort +20500 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20501 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +20502 3d/compare-eax-and 0/imm32 +20503 0f 84/jump-if-= $check-mu-copy-stmt:error-output-not-in-register/disp32 +20504 # if inout is not a scalar, abort +20505 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20506 (size-of %eax) # => eax +20507 3d/compare-eax-and 4/imm32 +20508 0f 8f/jump-if-> $check-mu-copy-stmt:error-inout-too-large/disp32 +20509 # var output-type/eax: (addr type-tree) = output->value->type +20510 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20511 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20512 # if (inout-type == output-type) return +20513 (type-match? %eax %ecx %edx) # => eax +20514 3d/compare-eax-and 0/imm32 +20515 0f 85/jump-if-!= $check-mu-copy-stmt:end/disp32 +20516 # if output is an addr and inout is 0, return +20517 { +20518 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20519 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20520 (is-mu-addr-type? %eax) # => eax +20521 3d/compare-eax-and 0/imm32/false +20522 74/jump-if-= break/disp8 +20523 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20524 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20525 (string-equal? %eax "0") # => eax +20526 3d/compare-eax-and 0/imm32/false +20527 74/jump-if-= break/disp8 +20528 e9/jump $check-mu-copy-stmt:end/disp32 +20529 } +20530 # if output is an offset and inout is 0, return +20531 { +20532 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20533 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20534 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +20535 75/jump-if-!= break/disp8 +20536 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +20537 (is-simple-mu-type? %eax 7) # offset => eax +20538 3d/compare-eax-and 0/imm32/false +20539 74/jump-if-= break/disp8 +20540 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20541 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20542 (string-equal? %eax "0") # => eax +20543 3d/compare-eax-and 0/imm32/false +20544 74/jump-if-= break/disp8 +20545 eb/jump $check-mu-copy-stmt:end/disp8 +20546 } +20547 # if output is not number-like, abort +20548 (check-mu-numberlike-output %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20549 $check-mu-copy-stmt:end: +20550 # . reclaim locals +20551 81 0/subop/add %esp 0x6c/imm32 +20552 # . restore registers +20553 5f/pop-to-edi +20554 5e/pop-to-esi +20555 5a/pop-to-edx +20556 59/pop-to-ecx +20557 58/pop-to-eax +20558 # . epilogue +20559 89/<- %esp 5/r32/ebp +20560 5d/pop-to-ebp +20561 c3/return +20562 +20563 $check-mu-copy-stmt:error-no-inout: +20564 (write-buffered *(ebp+0x10) "fn ") +20565 8b/-> *(ebp+0xc) 0/r32/eax +20566 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20567 (write-buffered *(ebp+0x10) %eax) +20568 (write-buffered *(ebp+0x10) ": stmt 'copy' expects an inout\n") +20569 (flush *(ebp+0x10)) +20570 (stop *(ebp+0x14) 1) +20571 # never gets here +20572 +20573 $check-mu-copy-stmt:error-too-many-inouts: +20574 (write-buffered *(ebp+0x10) "fn ") +20575 8b/-> *(ebp+0xc) 0/r32/eax +20576 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20577 (write-buffered *(ebp+0x10) %eax) +20578 (write-buffered *(ebp+0x10) ": stmt 'copy' must have just one inout\n") +20579 (flush *(ebp+0x10)) +20580 (stop *(ebp+0x14) 1) +20581 # never gets here +20582 +20583 $check-mu-copy-stmt:error-no-output: +20584 (write-buffered *(ebp+0x10) "fn ") +20585 8b/-> *(ebp+0xc) 0/r32/eax +20586 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20587 (write-buffered *(ebp+0x10) %eax) +20588 (write-buffered *(ebp+0x10) ": stmt 'copy' expects an output\n") +20589 (flush *(ebp+0x10)) +20590 (stop *(ebp+0x14) 1) +20591 # never gets here +20592 +20593 $check-mu-copy-stmt:error-output-not-in-register: +20594 (write-buffered *(ebp+0x10) "fn ") +20595 8b/-> *(ebp+0xc) 0/r32/eax +20596 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20597 (write-buffered *(ebp+0x10) %eax) +20598 (write-buffered *(ebp+0x10) ": stmt copy: output '") +20599 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20600 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20601 (write-buffered *(ebp+0x10) %eax) +20602 (write-buffered *(ebp+0x10) "' not in a register\n") +20603 (flush *(ebp+0x10)) +20604 (stop *(ebp+0x14) 1) +20605 # never gets here +20606 +20607 $check-mu-copy-stmt:error-too-many-outputs: +20608 (write-buffered *(ebp+0x10) "fn ") +20609 8b/-> *(ebp+0xc) 0/r32/eax +20610 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20611 (write-buffered *(ebp+0x10) %eax) +20612 (write-buffered *(ebp+0x10) ": stmt 'copy' must have just one output\n") +20613 (flush *(ebp+0x10)) +20614 (stop *(ebp+0x14) 1) +20615 # never gets here +20616 +20617 $check-mu-copy-stmt:error-inout-too-large: +20618 (write-buffered *(ebp+0x10) "fn ") +20619 8b/-> *(ebp+0xc) 0/r32/eax +20620 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20621 (write-buffered *(ebp+0x10) %eax) +20622 (write-buffered *(ebp+0x10) ": stmt copy: '") +20623 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20624 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20625 (write-buffered *(ebp+0x10) %eax) +20626 (write-buffered *(ebp+0x10) "' is too large to fit in a register\n") +20627 (flush *(ebp+0x10)) +20628 (stop *(ebp+0x14) 1) +20629 # never gets here +20630 +20631 check-mu-copy-to-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +20632 # . prologue +20633 55/push-ebp +20634 89/<- %ebp 4/r32/esp +20635 # . save registers +20636 50/push-eax +20637 51/push-ecx +20638 52/push-edx +20639 53/push-ebx +20640 56/push-esi +20641 57/push-edi +20642 # var type-parameters/edx: (addr table (handle array byte) (addr type-tree) 8) +20643 81 5/subop/subtract %esp 0x60/imm32 +20644 68/push 0x60/imm32/size +20645 68/push 0/imm32/read +20646 68/push 0/imm32/write +20647 89/<- %edx 4/r32/esp +20648 # esi = stmt +20649 8b/-> *(ebp+8) 6/r32/esi +20650 $check-mu-copy-to-stmt:check-for-output: +20651 # if stmt->outputs abort +20652 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +20653 3d/compare-eax-and 0/imm32 +20654 0f 85/jump-if-!= $check-mu-copy-to-stmt:error-too-many-outputs/disp32 +20655 $check-mu-copy-to-stmt:get-dest: +20656 # var dest/edi: (addr stmt-var) = stmt->inouts +20657 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +20658 89/<- %edi 0/r32/eax +20659 # zero inouts +20660 3d/compare-eax-and 0/imm32 +20661 0f 84/jump-if-= $check-mu-copy-to-stmt:error-incorrect-inouts/disp32 +20662 $check-mu-copy-to-stmt:get-src: +20663 # var src/esi: (addr stmt-var) = dest->next +20664 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +20665 89/<- %esi 0/r32/eax +20666 # 1 inout +20667 3d/compare-eax-and 0/imm32 +20668 0f 84/jump-if-= $check-mu-copy-to-stmt:error-incorrect-inouts/disp32 +20669 # > 2 inouts +20670 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +20671 3d/compare-eax-and 0/imm32 +20672 0f 85/jump-if-!= $check-mu-copy-to-stmt:error-incorrect-inouts/disp32 +20673 $check-mu-copy-to-stmt:types: +20674 # var src-type/ecx: (addr type-tree) = src->value->type +20675 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20676 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20677 89/<- %ecx 0/r32/eax +20678 # if src not in register or literal, abort +20679 # (we can't use stack-offset because it hasn't been computed yet) +20680 { +20681 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20682 (lookup *(eax+0x8) *(eax+0xc)) # Var-type Var-type => eax +20683 (is-simple-mu-type? %eax 0) # => eax +20684 3d/compare-eax-and 0/imm32 +20685 75/jump-if-!= break/disp8 +20686 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20687 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +20688 3d/compare-eax-and 0/imm32 +20689 75/jump-if-!= break/disp8 +20690 e9/jump $check-mu-copy-to-stmt:error-src-not-literal-or-in-register/disp32 +20691 } +20692 # if src is not a scalar, abort +20693 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20694 (size-of %eax) # => eax +20695 3d/compare-eax-and 4/imm32 +20696 0f 8f/jump-if-> $check-mu-copy-to-stmt:error-src-too-large/disp32 +20697 # var dest-type/ebx: (addr type-tree) = dest->value->type +20698 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20699 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20700 89/<- %ebx 0/r32/eax +20701 # if (dest->is-deref?) dest-type = dest-type->payload +20702 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref +20703 3d/compare-eax-and 0/imm32/false +20704 { +20705 74/jump-if-= break/disp8 +20706 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +20707 # if dest-type->right is null, dest-type = dest-type->left +20708 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +20709 { +20710 75/jump-if-!= break/disp8 +20711 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +20712 } +20713 89/<- %ebx 0/r32/eax 20714 } -20715 $check-final-stmt-is-return:check-tag: -20716 # if curr->value->tag != Stmt1, abort -20717 (lookup *ecx *(ecx+4)) # List-value List-value => eax -20718 81 7/subop/compare *eax 1/imm32/stmt1 # Stmt-tag -20719 75/jump-if-!= $check-final-stmt-is-return:error/disp8 -20720 $check-final-stmt-is-return:check-operation: -20721 # if curr->operation != "return", abort -20722 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -20723 (string-equal? %eax "return") -20724 3d/compare-eax-and 0/imm32/false -20725 74/jump-if-= $check-final-stmt-is-return:error/disp8 -20726 $check-final-stmt-is-return:end: -20727 # . restore registers -20728 59/pop-to-ecx -20729 58/pop-to-eax -20730 # . epilogue -20731 89/<- %esp 5/r32/ebp -20732 5d/pop-to-ebp -20733 c3/return -20734 -20735 $check-final-stmt-is-return:error: -20736 (write-buffered *(ebp+0x10) "fn ") -20737 8b/-> *(ebp+0xc) 0/r32/eax -20738 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20739 (write-buffered *(ebp+0x10) %eax) -20740 (write-buffered *(ebp+0x10) ": final statement should be a 'return'\n") -20741 (flush *(ebp+0x10)) -20742 (stop *(ebp+0x14) 1) -20743 # never gets here -20744 -20745 check-no-breaks: # block: (addr block), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -20746 # . prologue -20747 55/push-ebp -20748 89/<- %ebp 4/r32/esp -20749 # . save registers -20750 50/push-eax -20751 51/push-ecx -20752 # var curr/ecx: (addr list stmt) = block->stmts -20753 8b/-> *(ebp+8) 0/r32/eax -20754 (lookup *(eax+4) *(eax+8)) # Block-stmts Block-stmts => eax -20755 3d/compare-eax-and 0/imm32 -20756 0f 84/jump-if-= $check-no-breaks:end/disp32 -20757 89/<- %ecx 0/r32/eax -20758 { -20759 # if curr->next == 0, break -20760 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -20761 3d/compare-eax-and 0/imm32 -20762 74/jump-if-= break/disp8 -20763 # if curr->value->tag != Stmt1, continue -20764 (lookup *ecx *(ecx+4)) # List-value List-value => eax -20765 81 7/subop/compare *eax 1/imm32/stmt1 # Stmt-tag -20766 75/jump-if-!= $check-no-breaks:continue/disp8 -20767 # if curr->value->operation starts with "break", abort -20768 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -20769 (string-starts-with? %eax "break") # => eax -20770 3d/compare-eax-and 0/imm32/false -20771 75/jump-if-!= $check-no-breaks:error/disp8 -20772 $check-no-breaks:continue: -20773 # curr = curr->next -20774 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -20775 89/<- %ecx 0/r32/eax -20776 e9/jump loop/disp32 -20777 } -20778 $check-no-breaks:end: -20779 # . restore registers -20780 59/pop-to-ecx -20781 58/pop-to-eax -20782 # . epilogue -20783 89/<- %esp 5/r32/ebp -20784 5d/pop-to-ebp -20785 c3/return -20786 -20787 $check-no-breaks:error: -20788 (write-buffered *(ebp+0x10) "fn ") -20789 8b/-> *(ebp+0xc) 0/r32/eax -20790 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20791 (write-buffered *(ebp+0x10) %eax) -20792 (write-buffered *(ebp+0x10) " has outputs, so you cannot 'break' out of the outermost block. Use 'return'.\n") -20793 (flush *(ebp+0x10)) -20794 (stop *(ebp+0x14) 1) -20795 # never gets here -20796 -20797 check-mu-get-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -20798 # . prologue -20799 55/push-ebp -20800 89/<- %ebp 4/r32/esp -20801 # . save registers -20802 50/push-eax -20803 51/push-ecx -20804 52/push-edx -20805 53/push-ebx -20806 56/push-esi -20807 57/push-edi -20808 # esi = stmt -20809 8b/-> *(ebp+8) 6/r32/esi -20810 # - check for 0 inouts -20811 # var base/ecx: (addr var) = stmt->inouts->value -20812 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -20813 3d/compare-eax-and 0/imm32/false -20814 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 -20815 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -20816 89/<- %ecx 0/r32/eax -20817 $check-mu-get-stmt:check-base: -20818 # - check base type -20819 # if it's an 'addr', check that it's in a register -20820 # var base-type/ebx: (addr type-tree) = lookup(base->type) -20821 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -20822 89/<- %ebx 0/r32/eax -20823 { -20824 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -20825 0f 85/jump-if-!= break/disp32 -20826 $check-mu-get-stmt:base-is-compound: -20827 # if (type->left != addr) break -20828 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -20829 (is-simple-mu-type? %eax 2) # addr => eax -20830 3d/compare-eax-and 0/imm32/false -20831 74/jump-if-= break/disp8 -20832 $check-mu-get-stmt:base-is-addr: -20833 # now check for register -20834 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -20835 0f 84/jump-if-= $check-mu-get-stmt:error-base-type-addr-but-not-register/disp32 -20836 $check-mu-get-stmt:base-is-addr-in-register: -20837 # type->left is now an addr; skip it -20838 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -20839 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -20840 0f 85/jump-if-!= $check-mu-get-stmt:error-bad-base/disp32 -20841 $check-mu-get-stmt:base-is-addr-to-atom-in-register: -20842 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20843 89/<- %ebx 0/r32/eax -20844 } -20845 $check-mu-get-stmt:check-base-typeinfo: -20846 # ensure type is a container -20847 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -20848 { -20849 75/jump-if-!= break/disp8 -20850 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -20851 89/<- %ebx 0/r32/eax -20852 } -20853 # var base-type-id/ebx: type-id = base-type->value -20854 8b/-> *(ebx+4) 3/r32/ebx # Type-tree-value -20855 (is-container? %ebx) # => eax -20856 3d/compare-eax-and 0/imm32/false -20857 0f 84/jump-if-= $check-mu-get-stmt:error-bad-base/disp32 -20858 # var base-typeinfo/edx: (addr typeinfo) = find-typeinfo(base-type-id) -20859 # . var container/ecx: (handle typeinfo) -20860 68/push 0/imm32 -20861 68/push 0/imm32 -20862 89/<- %ecx 4/r32/esp -20863 # . -20864 (find-typeinfo %ebx %ecx) -20865 (lookup *ecx *(ecx+4)) # => eax -20866 # . reclaim container -20867 81 0/subop/add %esp 8/imm32 -20868 # . -20869 89/<- %edx 0/r32/eax -20870 # var offset/ecx: (addr stmt-var) = stmt->inouts->next -20871 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -20872 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -20873 89/<- %ecx 0/r32/eax -20874 # - check for 1 inout -20875 3d/compare-eax-and 0/imm32/false -20876 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 -20877 # var offset/ecx: (addr var) = lookup(offset->value) -20878 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -20879 89/<- %ecx 0/r32/eax -20880 # - check for valid field -20881 81 7/subop/compare *(ecx+0x14) -1/imm32/uninitialized # Var-offset -20882 0f 84/jump-if-= $check-mu-get-stmt:error-bad-field/disp32 -20883 # - check for too many inouts -20884 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -20885 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -20886 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -20887 3d/compare-eax-and 0/imm32/false -20888 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-inouts/disp32 -20889 # var output/edi: (addr var) = stmt->outputs->value -20890 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -20891 # - check for 0 outputs -20892 3d/compare-eax-and 0/imm32/false -20893 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-outputs/disp32 -20894 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -20895 89/<- %edi 0/r32/eax -20896 $check-mu-get-stmt:check-output-type: -20897 # - check output type -20898 # must be in register -20899 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax -20900 3d/compare-eax-and 0/imm32 -20901 0f 84/jump-if-= $check-mu-get-stmt:error-output-not-in-register/disp32 -20902 # must have a non-atomic type -20903 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -20904 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -20905 0f 85/jump-if-!= $check-mu-get-stmt:error-output-type-not-address/disp32 -20906 # type must start with (addr ...) -20907 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20908 (is-simple-mu-type? %eax 2) # => eax -20909 3d/compare-eax-and 0/imm32/false -20910 0f 84/jump-if-= $check-mu-get-stmt:error-output-type-not-address/disp32 -20911 $check-mu-get-stmt:check-output-type-match: -20912 # payload of addr type must match 'type' definition -20913 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -20914 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -20915 # if (payload->right == null) payload = payload->left -20916 81 7/subop/compare *(eax+0xc) 0/imm32/null # Type-tree-right -20917 { -20918 75/jump-if-!= break/disp8 -20919 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -20920 } -20921 89/<- %edi 0/r32/eax -20922 # . var output-name/ecx: (addr array byte) -20923 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -20924 89/<- %ecx 0/r32/eax -20925 # . var base-typeinfo-entry/eax: (addr handle typeinfo-entry) -20926 (lookup *(edx+4) *(edx+8)) # Typeinfo-fields Typeinfo-fields => eax -20927 (get %eax %ecx 0x10) # => eax -20928 # . -20929 (lookup *eax *(eax+4)) # => eax -20930 (lookup *eax *(eax+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax -20931 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -20932 # . -20933 (type-equal? %edi %eax) # => eax -20934 3d/compare-eax-and 0/imm32/false -20935 0f 84/jump-if-= $check-mu-get-stmt:error-bad-output-type/disp32 -20936 # - check for too many outputs -20937 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -20938 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -20939 3d/compare-eax-and 0/imm32/false -20940 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-outputs/disp32 -20941 $check-mu-get-stmt:end: -20942 # . restore registers -20943 5f/pop-to-edi -20944 5e/pop-to-esi -20945 5b/pop-to-ebx -20946 5a/pop-to-edx -20947 59/pop-to-ecx -20948 58/pop-to-eax -20949 # . epilogue -20950 89/<- %esp 5/r32/ebp -20951 5d/pop-to-ebp -20952 c3/return -20953 -20954 $check-mu-get-stmt:error-too-few-inouts: -20955 (write-buffered *(ebp+0x10) "fn ") -20956 8b/-> *(ebp+0xc) 0/r32/eax -20957 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20958 (write-buffered *(ebp+0x10) %eax) -20959 (write-buffered *(ebp+0x10) ": stmt get: too few inouts (2 required)\n") -20960 (flush *(ebp+0x10)) -20961 (stop *(ebp+0x14) 1) -20962 # never gets here -20963 -20964 $check-mu-get-stmt:error-too-many-inouts: -20965 (write-buffered *(ebp+0x10) "fn ") -20966 8b/-> *(ebp+0xc) 0/r32/eax -20967 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20968 (write-buffered *(ebp+0x10) %eax) -20969 (write-buffered *(ebp+0x10) ": stmt get: too many inouts (2 required)\n") -20970 (flush *(ebp+0x10)) -20971 (stop *(ebp+0x14) 1) -20972 # never gets here -20973 -20974 $check-mu-get-stmt:error-too-few-outputs: -20975 (write-buffered *(ebp+0x10) "fn ") -20976 8b/-> *(ebp+0xc) 0/r32/eax -20977 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20978 (write-buffered *(ebp+0x10) %eax) -20979 (write-buffered *(ebp+0x10) ": stmt get: must have an output\n") -20980 (flush *(ebp+0x10)) -20981 (stop *(ebp+0x14) 1) -20982 # never gets here -20983 -20984 $check-mu-get-stmt:error-too-many-outputs: -20985 (write-buffered *(ebp+0x10) "fn ") -20986 8b/-> *(ebp+0xc) 0/r32/eax -20987 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20988 (write-buffered *(ebp+0x10) %eax) -20989 (write-buffered *(ebp+0x10) ": stmt get: too many outputs (1 required)\n") -20990 (flush *(ebp+0x10)) -20991 (stop *(ebp+0x14) 1) -20992 # never gets here -20993 -20994 $check-mu-get-stmt:error-bad-base: -20995 # error("fn " fn ": stmt get: var '" base->name "' must have a 'type' definition\n") -20996 (write-buffered *(ebp+0x10) "fn ") -20997 8b/-> *(ebp+0xc) 0/r32/eax -20998 (lookup *eax *(eax+4)) # Function-name Function-name => eax -20999 (write-buffered *(ebp+0x10) %eax) -21000 (write-buffered *(ebp+0x10) ": stmt get: var '") -21001 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21002 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21003 (lookup *eax *(eax+4)) # Var-name Var-name => eax -21004 (write-buffered *(ebp+0x10) %eax) -21005 (write-buffered *(ebp+0x10) "' must have a 'type' definition\n") -21006 (flush *(ebp+0x10)) -21007 (stop *(ebp+0x14) 1) -21008 # never gets here -21009 -21010 $check-mu-get-stmt:error-base-type-addr-but-not-register: -21011 (write-buffered *(ebp+0x10) "fn ") -21012 8b/-> *(ebp+0xc) 0/r32/eax -21013 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21014 (write-buffered *(ebp+0x10) %eax) -21015 (write-buffered *(ebp+0x10) ": stmt get: var '") -21016 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21017 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21018 (lookup *eax *(eax+4)) # Var-name Var-name => eax -21019 (write-buffered *(ebp+0x10) %eax) -21020 (write-buffered *(ebp+0x10) "' is an 'addr' type, and so must live in a register\n") -21021 (flush *(ebp+0x10)) -21022 (stop *(ebp+0x14) 1) -21023 # never gets here -21024 -21025 $check-mu-get-stmt:error-bad-field: -21026 # error("fn " fn ": stmt get: type " type " has no member called '" curr->name "'\n") -21027 (write-buffered *(ebp+0x10) "fn ") -21028 8b/-> *(ebp+0xc) 0/r32/eax -21029 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21030 (write-buffered *(ebp+0x10) %eax) -21031 (write-buffered *(ebp+0x10) ": stmt get: type '") -21032 # . write(Type-id->data[tmp]) -21033 bf/copy-to-edi Type-id/imm32 -21034 8b/-> *(edi+ebx<<2+0xc) 6/r32/esi -21035 { -21036 81 7/subop/compare %esi 0/imm32 -21037 74/jump-if-= break/disp8 -21038 (write-buffered *(ebp+0x10) %esi) -21039 } -21040 # . -21041 (write-buffered *(ebp+0x10) "' has no member called '") -21042 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21043 (write-buffered *(ebp+0x10) %eax) -21044 (write-buffered *(ebp+0x10) "'\n") -21045 (flush *(ebp+0x10)) -21046 (stop *(ebp+0x14) 1) -21047 # never gets here -21048 -21049 $check-mu-get-stmt:error-output-not-in-register: -21050 (write-buffered *(ebp+0x10) "fn ") -21051 8b/-> *(ebp+0xc) 0/r32/eax -21052 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21053 (write-buffered *(ebp+0x10) %eax) -21054 (write-buffered *(ebp+0x10) ": stmt get: output '") -21055 (lookup *edi *(edi+4)) # Var-name Var-name => eax -21056 (write-buffered *(ebp+0x10) %eax) -21057 (write-buffered *(ebp+0x10) "' is not in a register\n") -21058 (flush *(ebp+0x10)) -21059 (stop *(ebp+0x14) 1) -21060 # never gets here -21061 -21062 $check-mu-get-stmt:error-output-type-not-address: -21063 (write-buffered *(ebp+0x10) "fn ") -21064 8b/-> *(ebp+0xc) 0/r32/eax -21065 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21066 (write-buffered *(ebp+0x10) %eax) -21067 (write-buffered *(ebp+0x10) ": stmt get: output must be an addr\n") -21068 (flush *(ebp+0x10)) -21069 (stop *(ebp+0x14) 1) -21070 # never gets here -21071 -21072 $check-mu-get-stmt:error-bad-output-type: -21073 (write-buffered *(ebp+0x10) "fn ") -21074 8b/-> *(ebp+0xc) 0/r32/eax -21075 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21076 (write-buffered *(ebp+0x10) %eax) -21077 (write-buffered *(ebp+0x10) ": stmt get: wrong output type for member '") -21078 (write-buffered *(ebp+0x10) %ecx) -21079 (write-buffered *(ebp+0x10) "' of type '") -21080 bf/copy-to-edi Type-id/imm32 -21081 8b/-> *(edi+ebx<<2+0xc) 6/r32/esi -21082 { -21083 81 7/subop/compare %esi 0/imm32 -21084 74/jump-if-= break/disp8 -21085 (write-buffered *(ebp+0x10) %esi) -21086 } -21087 (write-buffered *(ebp+0x10) "'\n") -21088 (flush *(ebp+0x10)) -21089 (stop *(ebp+0x14) 1) -21090 # never gets here -21091 -21092 check-mu-index-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -21093 # . prologue -21094 55/push-ebp -21095 89/<- %ebp 4/r32/esp -21096 # . save registers -21097 50/push-eax -21098 51/push-ecx -21099 52/push-edx -21100 53/push-ebx -21101 56/push-esi -21102 57/push-edi -21103 # esi = stmt -21104 8b/-> *(ebp+8) 6/r32/esi -21105 # - check for 0 inouts -21106 # var base/ecx: (addr var) = stmt->inouts->value -21107 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21108 $check-mu-index-stmt:check-no-inouts: -21109 3d/compare-eax-and 0/imm32 -21110 0f 84/jump-if-= $check-mu-index-stmt:error-too-few-inouts/disp32 -21111 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21112 89/<- %ecx 0/r32/eax -21113 # - check base type is either (addr array ...) in register or (array ...) on stack -21114 # var base-type/ebx: (addr type-tree) = lookup(base->type) -21115 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -21116 89/<- %ebx 0/r32/eax -21117 # if base-type is an atom, abort with a precise error -21118 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -21119 { -21120 74/jump-if-= break/disp8 -21121 (is-simple-mu-type? %ebx 3) # array => eax -21122 3d/compare-eax-and 0/imm32/false -21123 0f 85/jump-if-!= $check-mu-index-stmt:error-base-array-atom-type/disp32 -21124 0f 84/jump-if-= $check-mu-index-stmt:error-base-non-array-type/disp32 -21125 } -21126 $check-mu-index-stmt:base-is-compound: -21127 # if type->left not addr or array, abort -21128 { -21129 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21130 (is-simple-mu-type? %eax 2) # addr => eax -21131 3d/compare-eax-and 0/imm32/false -21132 75/jump-if-!= break/disp8 -21133 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21134 (is-simple-mu-type? %eax 3) # array => eax -21135 3d/compare-eax-and 0/imm32/false -21136 75/jump-if-!= break/disp8 -21137 e9/jump $check-mu-index-stmt:error-base-non-array-type/disp32 -21138 } -21139 # if (type->left == addr) ensure type->right->left == array and type->register exists -21140 { -21141 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21142 (is-simple-mu-type? %eax 2) # addr => eax -21143 3d/compare-eax-and 0/imm32/false -21144 74/jump-if-= break/disp8 -21145 $check-mu-index-stmt:base-is-addr: -21146 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -21147 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -21148 (is-simple-mu-type? %eax 3) # array => eax -21149 3d/compare-eax-and 0/imm32/false -21150 0f 84/jump-if-= $check-mu-index-stmt:error-base-non-array-type/disp32 -21151 $check-mu-index-stmt:check-base-addr-is-register: -21152 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -21153 0f 84/jump-if-= $check-mu-index-stmt:error-base-address-array-type-on-stack/disp32 -21154 } -21155 # if (type->left == array) ensure type->register doesn't exist -21156 { -21157 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21158 (is-simple-mu-type? %eax 3) # array => eax -21159 3d/compare-eax-and 0/imm32/false -21160 74/jump-if-= break/disp8 -21161 $check-mu-index-stmt:base-is-array: -21162 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -21163 0f 85/jump-if-!= $check-mu-index-stmt:error-base-array-type-in-register/disp32 -21164 } -21165 # if (base-type->left == addr) base-type = base-type->right -21166 { -21167 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21168 (is-simple-mu-type? %eax 2) # addr => eax -21169 3d/compare-eax-and 0/imm32/false -21170 74/jump-if-= break/disp8 -21171 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -21172 89/<- %ebx 0/r32/eax -21173 } -21174 # - check for 1 inout -21175 # var index/ecx: (addr stmt-var) = stmt->inouts->next->value -21176 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21177 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21178 $check-mu-index-stmt:check-single-inout: -21179 3d/compare-eax-and 0/imm32 -21180 0f 84/jump-if-= $check-mu-index-stmt:error-too-few-inouts/disp32 -21181 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21182 89/<- %ecx 0/r32/eax -21183 # - check index is either a literal or register -21184 # var index-type/edx: (addr type-tree) -21185 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -21186 89/<- %edx 0/r32/eax -21187 # if index type is an atom, it must be a literal or int -21188 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom -21189 { -21190 74/jump-if-= break/disp8 -21191 $check-mu-index-stmt:index-type-is-atom: -21192 (is-simple-mu-type? %edx 0) # literal => eax -21193 3d/compare-eax-and 0/imm32/false -21194 75/jump-if-!= $check-mu-index-stmt:index-type-done/disp8 -21195 (is-simple-mu-type? %edx 1) # int => eax -21196 3d/compare-eax-and 0/imm32/false -21197 75/jump-if-!= $check-mu-index-stmt:index-type-done/disp8 -21198 (is-simple-mu-type? %edx 7) # offset => eax -21199 3d/compare-eax-and 0/imm32/false -21200 0f 85/jump-if-!= $check-mu-index-stmt:error-index-offset-atom-type/disp32 -21201 e9/jump $check-mu-index-stmt:error-invalid-index-type/disp32 -21202 } -21203 # if index type is a non-atom: it must be an offset -21204 { -21205 75/jump-if-!= break/disp8 -21206 $check-mu-index-stmt:index-type-is-non-atom: -21207 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -21208 (is-simple-mu-type? %eax 7) # offset => eax -21209 3d/compare-eax-and 0/imm32/false -21210 0f 84/jump-if-= $check-mu-index-stmt:error-invalid-index-type/disp32 -21211 } -21212 $check-mu-index-stmt:index-type-done: -21213 # check index is either a literal or in a register -21214 { -21215 (is-simple-mu-type? %edx 0) # literal => eax -21216 3d/compare-eax-and 0/imm32/false -21217 75/jump-if-!= break/disp8 -21218 $check-mu-index-stmt:check-index-in-register: -21219 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -21220 0f 84/jump-if-= $check-mu-index-stmt:error-index-on-stack/disp32 -21221 } -21222 # - if index is an 'int', check that element type of base has size 1, 2, 4 or 8 bytes. -21223 { -21224 (is-simple-mu-type? %edx 1) # int => eax -21225 3d/compare-eax-and 0/imm32/false -21226 74/jump-if-= break/disp8 -21227 $check-mu-index-stmt:check-index-can-be-int: -21228 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21229 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21230 (array-element-size %eax) # => eax -21231 3d/compare-eax-and 1/imm32 -21232 74/jump-if-= break/disp8 -21233 3d/compare-eax-and 2/imm32 -21234 74/jump-if-= break/disp8 -21235 3d/compare-eax-and 4/imm32 -21236 74/jump-if-= break/disp8 -21237 3d/compare-eax-and 8/imm32 -21238 74/jump-if-= break/disp8 -21239 e9/jump $check-mu-index-stmt:error-index-needs-offset/disp32 -21240 } -21241 # - check for too many inouts -21242 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21243 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21244 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21245 3d/compare-eax-and 0/imm32/false -21246 0f 85/jump-if-!= $check-mu-index-stmt:error-too-many-inouts/disp32 -21247 # - check for 0 outputs -21248 # var output/edi: (addr var) = stmt->outputs->value -21249 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -21250 3d/compare-eax-and 0/imm32/false -21251 0f 84/jump-if-= $check-mu-index-stmt:error-too-few-outputs/disp32 -21252 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21253 89/<- %edi 0/r32/eax -21254 # - check output type -21255 # must have a non-atomic type -21256 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -21257 89/<- %edx 0/r32/eax -21258 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom -21259 0f 85/jump-if-!= $check-mu-index-stmt:error-output-type-not-address/disp32 -21260 # type must start with (addr ...) -21261 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -21262 (is-simple-mu-type? %eax 2) # addr => eax -21263 3d/compare-eax-and 0/imm32/false -21264 0f 84/jump-if-= $check-mu-index-stmt:error-output-type-not-address/disp32 -21265 # if tail(base-type) != tail(output-type) abort -21266 (type-tail %ebx) # => eax -21267 89/<- %ebx 0/r32/eax -21268 (type-tail %edx) # => eax -21269 (type-equal? %ebx %eax) # => eax -21270 3d/compare-eax-and 0/imm32/false -21271 0f 84/jump-if-= $check-mu-index-stmt:error-bad-output-type/disp32 -21272 # - check for too many outputs -21273 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -21274 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21275 3d/compare-eax-and 0/imm32/false -21276 0f 85/jump-if-!= $check-mu-index-stmt:error-too-many-outputs/disp32 -21277 $check-mu-index-stmt:end: -21278 # . restore registers -21279 5f/pop-to-edi -21280 5e/pop-to-esi -21281 5b/pop-to-ebx -21282 5a/pop-to-edx -21283 59/pop-to-ecx -21284 58/pop-to-eax -21285 # . epilogue -21286 89/<- %esp 5/r32/ebp -21287 5d/pop-to-ebp -21288 c3/return -21289 -21290 $check-mu-index-stmt:error-base-non-array-type: -21291 (write-buffered *(ebp+0x10) "fn ") -21292 8b/-> *(ebp+0xc) 0/r32/eax -21293 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21294 (write-buffered *(ebp+0x10) %eax) -21295 (write-buffered *(ebp+0x10) ": stmt index: var '") -21296 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21297 (write-buffered *(ebp+0x10) %eax) -21298 (write-buffered *(ebp+0x10) "' is not an array\n") -21299 (flush *(ebp+0x10)) -21300 (stop *(ebp+0x14) 1) -21301 # never gets here -21302 -21303 $check-mu-index-stmt:error-base-array-atom-type: -21304 (write-buffered *(ebp+0x10) "fn ") -21305 8b/-> *(ebp+0xc) 0/r32/eax -21306 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21307 (write-buffered *(ebp+0x10) %eax) -21308 (write-buffered *(ebp+0x10) ": stmt index: array '") -21309 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21310 (write-buffered *(ebp+0x10) %eax) -21311 (write-buffered *(ebp+0x10) "' must specify the type of its elements\n") -21312 (flush *(ebp+0x10)) -21313 (stop *(ebp+0x14) 1) -21314 # never gets here -21315 -21316 $check-mu-index-stmt:error-base-address-array-type-on-stack: -21317 (write-buffered *(ebp+0x10) "fn ") -21318 8b/-> *(ebp+0xc) 0/r32/eax -21319 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21320 (write-buffered *(ebp+0x10) %eax) -21321 (write-buffered *(ebp+0x10) ": stmt index: var '") -21322 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21323 (write-buffered *(ebp+0x10) %eax) -21324 (write-buffered *(ebp+0x10) "' is an addr to an array, and so must live in a register\n") -21325 (flush *(ebp+0x10)) -21326 (stop *(ebp+0x14) 1) -21327 # never gets here +20715 # if (src-type == dest-type) return +20716 (type-match? %ebx %ecx %edx) # => eax +20717 3d/compare-eax-and 0/imm32 +20718 0f 85/jump-if-!= $check-mu-copy-to-stmt:end/disp32 +20719 # if dest is an addr and src is 0, return +20720 { +20721 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20722 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20723 (is-mu-addr-type? %eax) # => eax +20724 3d/compare-eax-and 0/imm32/false +20725 74/jump-if-= break/disp8 +20726 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20727 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20728 (string-equal? %eax "0") # => eax +20729 3d/compare-eax-and 0/imm32/false +20730 74/jump-if-= break/disp8 +20731 eb/jump $check-mu-copy-to-stmt:end/disp8 +20732 } +20733 # if dest is not number-like, abort +20734 (check-mu-numberlike-arg %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20735 $check-mu-copy-to-stmt:end: +20736 # . reclaim locals +20737 81 0/subop/add %esp 0x6c/imm32 +20738 # . restore registers +20739 5f/pop-to-edi +20740 5e/pop-to-esi +20741 5b/pop-to-ebx +20742 5a/pop-to-edx +20743 59/pop-to-ecx +20744 58/pop-to-eax +20745 # . epilogue +20746 89/<- %esp 5/r32/ebp +20747 5d/pop-to-ebp +20748 c3/return +20749 +20750 $check-mu-copy-to-stmt:error-incorrect-inouts: +20751 (write-buffered *(ebp+0x10) "fn ") +20752 8b/-> *(ebp+0xc) 0/r32/eax +20753 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20754 (write-buffered *(ebp+0x10) %eax) +20755 (write-buffered *(ebp+0x10) ": stmt 'copy-to' must have two inouts\n") +20756 (flush *(ebp+0x10)) +20757 (stop *(ebp+0x14) 1) +20758 # never gets here +20759 +20760 $check-mu-copy-to-stmt:error-too-many-outputs: +20761 (write-buffered *(ebp+0x10) "fn ") +20762 8b/-> *(ebp+0xc) 0/r32/eax +20763 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20764 (write-buffered *(ebp+0x10) %eax) +20765 (write-buffered *(ebp+0x10) ": stmt 'copy-to' must not have any outputs\n") +20766 (flush *(ebp+0x10)) +20767 (stop *(ebp+0x14) 1) +20768 # never gets here +20769 +20770 $check-mu-copy-to-stmt:error-src-not-literal-or-in-register: +20771 (write-buffered *(ebp+0x10) "fn ") +20772 8b/-> *(ebp+0xc) 0/r32/eax +20773 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20774 (write-buffered *(ebp+0x10) %eax) +20775 (write-buffered *(ebp+0x10) ": stmt copy-to: source (second inout) is in memory\n") +20776 (flush *(ebp+0x10)) +20777 (stop *(ebp+0x14) 1) +20778 # never gets here +20779 +20780 $check-mu-copy-to-stmt:error-src-too-large: +20781 (write-buffered *(ebp+0x10) "fn ") +20782 8b/-> *(ebp+0xc) 0/r32/eax +20783 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20784 (write-buffered *(ebp+0x10) %eax) +20785 (write-buffered *(ebp+0x10) ": stmt copy-to: '") +20786 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20787 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20788 (write-buffered *(ebp+0x10) %eax) +20789 (write-buffered *(ebp+0x10) "' is too large to copy\n") +20790 (flush *(ebp+0x10)) +20791 (stop *(ebp+0x14) 1) +20792 # never gets here +20793 +20794 check-mu-compare-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +20795 # . prologue +20796 55/push-ebp +20797 89/<- %ebp 4/r32/esp +20798 # . save registers +20799 50/push-eax +20800 51/push-ecx +20801 52/push-edx +20802 53/push-ebx +20803 56/push-esi +20804 57/push-edi +20805 # var type-parameters/edx: (addr table (handle array byte) (addr type-tree) 8) +20806 81 5/subop/subtract %esp 0x60/imm32 +20807 68/push 0x60/imm32/size +20808 68/push 0/imm32/read +20809 68/push 0/imm32/write +20810 89/<- %edx 4/r32/esp +20811 # esi = stmt +20812 8b/-> *(ebp+8) 6/r32/esi +20813 $check-mu-compare-stmt:check-for-output: +20814 # if stmt->outputs abort +20815 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +20816 3d/compare-eax-and 0/imm32 +20817 0f 85/jump-if-!= $check-mu-compare-stmt:error-too-many-outputs/disp32 +20818 $check-mu-compare-stmt:get-left: +20819 # var left/edi: (addr stmt-var) = stmt->inouts +20820 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +20821 89/<- %edi 0/r32/eax +20822 # zero inouts +20823 3d/compare-eax-and 0/imm32 +20824 0f 84/jump-if-= $check-mu-compare-stmt:error-incorrect-inouts/disp32 +20825 $check-mu-compare-stmt:get-right: +20826 # var right/esi: (addr stmt-var) = left->next +20827 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +20828 89/<- %esi 0/r32/eax +20829 # 1 inout +20830 3d/compare-eax-and 0/imm32 +20831 0f 84/jump-if-= $check-mu-compare-stmt:error-incorrect-inouts/disp32 +20832 # > 2 inouts +20833 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +20834 3d/compare-eax-and 0/imm32 +20835 0f 85/jump-if-!= $check-mu-compare-stmt:error-incorrect-inouts/disp32 +20836 # if both inouts are in memory, abort +20837 { +20838 $check-mu-compare-stmt:both-in-mem: +20839 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20840 (lookup *(eax+0x8) *(eax+0xc)) # Var-type Var-type => eax +20841 (is-simple-mu-type? %eax 0) # => eax +20842 3d/compare-eax-and 0/imm32 +20843 0f 85/jump-if-!= break/disp32 +20844 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20845 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +20846 3d/compare-eax-and 0/imm32 +20847 75/jump-if-!= break/disp8 +20848 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20849 (lookup *(eax+0x8) *(eax+0xc)) # Var-type Var-type => eax +20850 (is-simple-mu-type? %eax 0) # => eax +20851 3d/compare-eax-and 0/imm32 +20852 75/jump-if-!= break/disp8 +20853 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20854 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +20855 3d/compare-eax-and 0/imm32 +20856 75/jump-if-!= break/disp8 +20857 e9/jump $check-mu-compare-stmt:error-both-in-memory/disp32 +20858 } +20859 $check-mu-compare-stmt:types: +20860 # var right-type/ecx: (addr type-tree) = right->value->type +20861 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20862 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20863 89/<- %ecx 0/r32/eax +20864 # if (right->is-deref?) right-type = right-type->payload +20865 8b/-> *(esi+0x10) 0/r32/eax # Stmt-var-is-deref +20866 3d/compare-eax-and 0/imm32/false +20867 { +20868 74/jump-if-= break/disp8 +20869 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +20870 # if right-type->right is null, right-type = right-type->left +20871 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +20872 { +20873 75/jump-if-!= break/disp8 +20874 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +20875 } +20876 89/<- %ecx 0/r32/eax +20877 } +20878 # if right is not a scalar, abort +20879 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20880 (size-of %eax) # => eax +20881 3d/compare-eax-and 4/imm32 +20882 0f 8f/jump-if-> $check-mu-compare-stmt:error-right-too-large/disp32 +20883 # if left is not a scalar, abort +20884 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20885 (size-of %eax) # => eax +20886 3d/compare-eax-and 4/imm32 +20887 0f 8f/jump-if-> $check-mu-compare-stmt:error-left-too-large/disp32 +20888 # var left-type/ebx: (addr type-tree) = left->value->type +20889 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20890 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20891 89/<- %ebx 0/r32/eax +20892 # if (left->is-deref?) left-type = left-type->payload +20893 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref +20894 3d/compare-eax-and 0/imm32/false +20895 { +20896 74/jump-if-= break/disp8 +20897 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +20898 # if left-type->right is null, left-type = left-type->left +20899 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +20900 { +20901 75/jump-if-!= break/disp8 +20902 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +20903 } +20904 89/<- %ebx 0/r32/eax +20905 } +20906 # if (left-type == right-type) return +20907 (type-match? %ebx %ecx %edx) # => eax +20908 3d/compare-eax-and 0/imm32 +20909 0f 85/jump-if-!= $check-mu-compare-stmt:end/disp32 +20910 # if left is an addr and right is 0, return +20911 { +20912 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20913 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +20914 (is-mu-addr-type? %eax) # => eax +20915 3d/compare-eax-and 0/imm32/false +20916 74/jump-if-= break/disp8 +20917 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20918 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20919 (string-equal? %eax "0") # => eax +20920 3d/compare-eax-and 0/imm32/false +20921 74/jump-if-= break/disp8 +20922 eb/jump $check-mu-compare-stmt:end/disp8 +20923 } +20924 # if left is not number-like, abort +20925 (check-mu-numberlike-arg %edi *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +20926 $check-mu-compare-stmt:end: +20927 # . reclaim locals +20928 81 0/subop/add %esp 0x6c/imm32 +20929 # . restore registers +20930 5f/pop-to-edi +20931 5e/pop-to-esi +20932 5b/pop-to-ebx +20933 5a/pop-to-edx +20934 59/pop-to-ecx +20935 58/pop-to-eax +20936 # . epilogue +20937 89/<- %esp 5/r32/ebp +20938 5d/pop-to-ebp +20939 c3/return +20940 +20941 $check-mu-compare-stmt:error-incorrect-inouts: +20942 (write-buffered *(ebp+0x10) "fn ") +20943 8b/-> *(ebp+0xc) 0/r32/eax +20944 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20945 (write-buffered *(ebp+0x10) %eax) +20946 (write-buffered *(ebp+0x10) ": stmt 'compare' must have two inouts\n") +20947 (flush *(ebp+0x10)) +20948 (stop *(ebp+0x14) 1) +20949 # never gets here +20950 +20951 $check-mu-compare-stmt:error-too-many-outputs: +20952 (write-buffered *(ebp+0x10) "fn ") +20953 8b/-> *(ebp+0xc) 0/r32/eax +20954 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20955 (write-buffered *(ebp+0x10) %eax) +20956 (write-buffered *(ebp+0x10) ": stmt 'compare' must not have any outputs\n") +20957 (flush *(ebp+0x10)) +20958 (stop *(ebp+0x14) 1) +20959 # never gets here +20960 +20961 $check-mu-compare-stmt:error-both-in-memory: +20962 (write-buffered *(ebp+0x10) "fn ") +20963 8b/-> *(ebp+0xc) 0/r32/eax +20964 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20965 (write-buffered *(ebp+0x10) %eax) +20966 (write-buffered *(ebp+0x10) ": stmt compare: both inouts are in memory\n") +20967 (flush *(ebp+0x10)) +20968 (stop *(ebp+0x14) 1) +20969 # never gets here +20970 +20971 $check-mu-compare-stmt:error-left-too-large: +20972 (write-buffered *(ebp+0x10) "fn ") +20973 8b/-> *(ebp+0xc) 0/r32/eax +20974 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20975 (write-buffered *(ebp+0x10) %eax) +20976 (write-buffered *(ebp+0x10) ": stmt compare: '") +20977 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +20978 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20979 (write-buffered *(ebp+0x10) %eax) +20980 (write-buffered *(ebp+0x10) "' is too large to compare\n") +20981 (flush *(ebp+0x10)) +20982 (stop *(ebp+0x14) 1) +20983 # never gets here +20984 +20985 $check-mu-compare-stmt:error-right-too-large: +20986 (write-buffered *(ebp+0x10) "fn ") +20987 8b/-> *(ebp+0xc) 0/r32/eax +20988 (lookup *eax *(eax+4)) # Function-name Function-name => eax +20989 (write-buffered *(ebp+0x10) %eax) +20990 (write-buffered *(ebp+0x10) ": stmt compare: '") +20991 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +20992 (lookup *eax *(eax+4)) # Var-name Var-name => eax +20993 (write-buffered *(ebp+0x10) %eax) +20994 (write-buffered *(ebp+0x10) "' is too large to compare\n") +20995 (flush *(ebp+0x10)) +20996 (stop *(ebp+0x14) 1) +20997 # never gets here +20998 +20999 check-mu-address-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +21000 # . prologue +21001 55/push-ebp +21002 89/<- %ebp 4/r32/esp +21003 # . save registers +21004 50/push-eax +21005 51/push-ecx +21006 52/push-edx +21007 56/push-esi +21008 57/push-edi +21009 $check-mu-address-stmt:get-output: +21010 # esi = stmt +21011 8b/-> *(ebp+8) 6/r32/esi +21012 # var output/edi: (addr stmt-var) = stmt->outputs +21013 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +21014 89/<- %edi 0/r32/eax +21015 # zero outputs +21016 3d/compare-eax-and 0/imm32 +21017 0f 84/jump-if-= $check-mu-address-stmt:error-no-output/disp32 +21018 # > 1 output +21019 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +21020 3d/compare-eax-and 0/imm32 +21021 0f 85/jump-if-!= $check-mu-address-stmt:error-too-many-outputs/disp32 +21022 $check-mu-address-stmt:get-inout: +21023 # var inout/esi: (addr stmt-var) = stmt->inouts +21024 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +21025 89/<- %esi 0/r32/eax +21026 # zero inouts +21027 3d/compare-eax-and 0/imm32 +21028 0f 84/jump-if-= $check-mu-address-stmt:error-no-inout/disp32 +21029 # > 1 inout +21030 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +21031 3d/compare-eax-and 0/imm32 +21032 0f 85/jump-if-!= $check-mu-address-stmt:error-too-many-inouts/disp32 +21033 $check-mu-address-stmt:types: +21034 # if output not in register, abort +21035 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +21036 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +21037 3d/compare-eax-and 0/imm32 +21038 0f 84/jump-if-= $check-mu-address-stmt:error-output-not-in-register/disp32 +21039 # var output-type/edx: (addr type-tree) = output->value->type +21040 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +21041 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +21042 89/<- %edx 0/r32/eax +21043 # if output-type not an addr, abort +21044 (is-mu-addr-type? %edx) # => eax +21045 3d/compare-eax-and 0/imm32/false +21046 0f 84/jump-if-= $check-mu-address-stmt:error-output-not-address/disp32 +21047 # output-type = output-type->right +21048 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax +21049 # if output-type->right is null, output-type = output-type->left +21050 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +21051 { +21052 75/jump-if-!= break/disp8 +21053 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21054 } +21055 89/<- %edx 0/r32/eax +21056 # var inout-type/ecx: (addr type-tree) = inout->value->type +21057 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +21058 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +21059 89/<- %ecx 0/r32/eax +21060 # if (inout->is-deref?) inout-type = inout-type->payload +21061 8b/-> *(esi+0x10) 0/r32/eax # Stmt-var-is-deref +21062 3d/compare-eax-and 0/imm32/false +21063 { +21064 74/jump-if-= break/disp8 +21065 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +21066 # if inout-type->right is null, t = inout-type->left +21067 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +21068 { +21069 75/jump-if-!= break/disp8 +21070 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21071 } +21072 89/<- %ecx 0/r32/eax +21073 } +21074 # if (inout-type != output-type) abort +21075 (type-equal-ignoring-capacity? %edx %ecx) # => eax +21076 3d/compare-eax-and 0/imm32 +21077 0f 84/jump-if-= $check-mu-address-stmt:error-type-mismatch/disp32 +21078 $check-mu-address-stmt:end: +21079 # . restore registers +21080 5f/pop-to-edi +21081 5e/pop-to-esi +21082 5a/pop-to-edx +21083 59/pop-to-ecx +21084 58/pop-to-eax +21085 # . epilogue +21086 89/<- %esp 5/r32/ebp +21087 5d/pop-to-ebp +21088 c3/return +21089 +21090 $check-mu-address-stmt:error-no-inout: +21091 (write-buffered *(ebp+0x10) "fn ") +21092 8b/-> *(ebp+0xc) 0/r32/eax +21093 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21094 (write-buffered *(ebp+0x10) %eax) +21095 (write-buffered *(ebp+0x10) ": stmt 'address' expects an inout\n") +21096 (flush *(ebp+0x10)) +21097 (stop *(ebp+0x14) 1) +21098 # never gets here +21099 +21100 $check-mu-address-stmt:error-too-many-inouts: +21101 (write-buffered *(ebp+0x10) "fn ") +21102 8b/-> *(ebp+0xc) 0/r32/eax +21103 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21104 (write-buffered *(ebp+0x10) %eax) +21105 (write-buffered *(ebp+0x10) ": stmt 'address' must have just one inout\n") +21106 (flush *(ebp+0x10)) +21107 (stop *(ebp+0x14) 1) +21108 # never gets here +21109 +21110 $check-mu-address-stmt:error-no-output: +21111 (write-buffered *(ebp+0x10) "fn ") +21112 8b/-> *(ebp+0xc) 0/r32/eax +21113 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21114 (write-buffered *(ebp+0x10) %eax) +21115 (write-buffered *(ebp+0x10) ": stmt 'address' expects an output\n") +21116 (flush *(ebp+0x10)) +21117 (stop *(ebp+0x14) 1) +21118 # never gets here +21119 +21120 $check-mu-address-stmt:error-output-not-in-register: +21121 (write-buffered *(ebp+0x10) "fn ") +21122 8b/-> *(ebp+0xc) 0/r32/eax +21123 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21124 (write-buffered *(ebp+0x10) %eax) +21125 (write-buffered *(ebp+0x10) ": stmt address: output '") +21126 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +21127 (lookup *eax *(eax+4)) # Var-name Var-name => eax +21128 (write-buffered *(ebp+0x10) %eax) +21129 (write-buffered *(ebp+0x10) "' not in a register\n") +21130 (flush *(ebp+0x10)) +21131 (stop *(ebp+0x14) 1) +21132 # never gets here +21133 +21134 $check-mu-address-stmt:error-too-many-outputs: +21135 (write-buffered *(ebp+0x10) "fn ") +21136 8b/-> *(ebp+0xc) 0/r32/eax +21137 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21138 (write-buffered *(ebp+0x10) %eax) +21139 (write-buffered *(ebp+0x10) ": stmt 'address' must have just one output\n") +21140 (flush *(ebp+0x10)) +21141 (stop *(ebp+0x14) 1) +21142 # never gets here +21143 +21144 $check-mu-address-stmt:error-output-not-address: +21145 (write-buffered *(ebp+0x10) "fn ") +21146 8b/-> *(ebp+0xc) 0/r32/eax +21147 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21148 (write-buffered *(ebp+0x10) %eax) +21149 (write-buffered *(ebp+0x10) ": stmt address: output '") +21150 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +21151 (lookup *eax *(eax+4)) # Var-name Var-name => eax +21152 (write-buffered *(ebp+0x10) %eax) +21153 (write-buffered *(ebp+0x10) "' is not an addr\n") +21154 (flush *(ebp+0x10)) +21155 (stop *(ebp+0x14) 1) +21156 # never gets here +21157 +21158 $check-mu-address-stmt:error-type-mismatch: +21159 (write-buffered *(ebp+0x10) "fn ") +21160 8b/-> *(ebp+0xc) 0/r32/eax +21161 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21162 (write-buffered *(ebp+0x10) %eax) +21163 (write-buffered *(ebp+0x10) ": stmt address: output '") +21164 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +21165 (lookup *eax *(eax+4)) # Var-name Var-name => eax +21166 (write-buffered *(ebp+0x10) %eax) +21167 (write-buffered *(ebp+0x10) "' cannot hold address of '") +21168 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +21169 (lookup *eax *(eax+4)) # Var-name Var-name => eax +21170 (write-buffered *(ebp+0x10) %eax) +21171 (write-buffered *(ebp+0x10) "'\n") +21172 (flush *(ebp+0x10)) +21173 (stop *(ebp+0x14) 1) +21174 # never gets here +21175 +21176 type-equal-ignoring-capacity?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean +21177 # . prologue +21178 55/push-ebp +21179 89/<- %ebp 4/r32/esp +21180 # . save registers +21181 51/push-ecx +21182 52/push-edx +21183 53/push-ebx +21184 # var curr-a/ecx: (addr type-tree) = a +21185 8b/-> *(ebp+8) 1/r32/ecx +21186 # var curr-b/ebx: (addr type-tree) = b +21187 8b/-> *(ebp+0xc) 3/r32/ebx +21188 # if (curr-a->is-atom?) fall back to regular equality +21189 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +21190 0f 85/jump-if-!= $type-equal-ignoring-capacity?:base-case/disp32 +21191 # if (curr-a->left != curr-b->left) return false +21192 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +21193 89/<- %edx 0/r32/eax +21194 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +21195 (type-equal? %edx %eax) # => eax +21196 3d/compare-eax-and 0/imm32/false +21197 0f 84/jump-if-= $type-equal-ignoring-capacity?:end/disp32 # eax switches meaning +21198 # if (curr-a->left == "array") curr-a = curr-a->element-type +21199 { +21200 (is-mu-array? %edx) # => eax +21201 3d/compare-eax-and 0/imm32/false +21202 75/jump-if-!= break/disp8 +21203 $type-equal-ignoring-capacity?:array: +21204 # curr-a = curr-a->right->left +21205 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +21206 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21207 89/<- %ecx 0/r32/eax +21208 # curr-b = curr-b->right->left +21209 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +21210 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21211 89/<- %ebx 0/r32/eax +21212 eb/jump $type-equal-ignoring-capacity?:base-case/disp8 +21213 } +21214 # if (curr-a->left == "stream") curr-a = curr-a->element-type +21215 { +21216 (is-mu-stream? %edx) # => eax +21217 3d/compare-eax-and 0/imm32/false +21218 75/jump-if-!= break/disp8 +21219 $type-equal-ignoring-capacity?:stream: +21220 # curr-a = curr-a->right->left +21221 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +21222 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21223 89/<- %ecx 0/r32/eax +21224 # curr-b = curr-b->right->left +21225 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +21226 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21227 89/<- %ebx 0/r32/eax +21228 eb/jump $type-equal-ignoring-capacity?:base-case/disp8 +21229 } +21230 $type-equal-ignoring-capacity?:base-case: +21231 # return type-equal?(curr-a, curr-b) +21232 (type-equal? %ecx %ebx) # => eax +21233 $type-equal-ignoring-capacity?:end: +21234 # . restore registers +21235 5b/pop-to-ebx +21236 5a/pop-to-edx +21237 59/pop-to-ecx +21238 # . epilogue +21239 89/<- %esp 5/r32/ebp +21240 5d/pop-to-ebp +21241 c3/return +21242 +21243 check-mu-return-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +21244 # . prologue +21245 55/push-ebp +21246 89/<- %ebp 4/r32/esp +21247 # . save registers +21248 50/push-eax +21249 51/push-ecx +21250 52/push-edx +21251 53/push-ebx +21252 56/push-esi +21253 57/push-edi +21254 # var type-parameters/edx: (addr table (handle array byte) (addr type-tree) 8) +21255 81 5/subop/subtract %esp 0x60/imm32 +21256 68/push 0x60/imm32/size +21257 68/push 0/imm32/read +21258 68/push 0/imm32/write +21259 89/<- %edx 4/r32/esp +21260 # var template/esi: (addr list var) = fn->outputs +21261 8b/-> *(ebp+0xc) 0/r32/eax +21262 (lookup *(eax+0x10) *(eax+0x14)) # Function-outputs Function-outputs => eax +21263 89/<- %esi 0/r32/eax +21264 # var curr-template/ebx: (addr list var) = fn->outputs +21265 89/<- %ebx 0/r32/eax +21266 # var curr/edi: (addr stmt-var) = stmt->inouts +21267 8b/-> *(ebp+8) 0/r32/eax +21268 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax +21269 89/<- %edi 0/r32/eax +21270 { +21271 # if template is null, break +21272 81 7/subop/compare %ebx 0/imm32 +21273 0f 84/jump-if-= break/disp32 +21274 # if curr is null, abort +21275 81 7/subop/compare %edi 0/imm32 +21276 0f 84/jump-if-= $check-mu-return-stmt:error-too-few-inouts/disp32 +21277 # var template-type/ecx: (addr type-tree) = template->value->type +21278 (lookup *ebx *(ebx+4)) # List-value List-value => eax +21279 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +21280 89/<- %ecx 0/r32/eax +21281 # var curr-type/eax: (addr type-tree) = curr->value->type +21282 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +21283 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +21284 # if (curr->is-deref?) curr-type = payload of curr-type +21285 81 7/subop/compare *(edi+0x10) 0/imm32/false # Stmt-var-is-deref +21286 { +21287 74/jump-if-= break/disp8 +21288 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +21289 # if t->right is null, t = t->left +21290 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +21291 75/jump-if-!= break/disp8 +21292 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21293 } +21294 # if (curr-type != template-type) abort +21295 (type-match? %ecx %eax %edx) # => eax +21296 3d/compare-eax-and 0/imm32/false +21297 0f 84/jump-if-= $check-mu-return-stmt:error1/disp32 +21298 # if register-within-list-with-conflict?(curr, original template, curr-template, stmt) abort +21299 (register-within-list-with-conflict? %edi %esi %ebx *(ebp+8)) # => eax +21300 3d/compare-eax-and 0/imm32/false +21301 0f 85/jump-if-!= $check-mu-return-stmt:error2/disp32 +21302 # template = template->next +21303 (lookup *(ebx+8) *(ebx+0xc)) # List-next List-next => eax +21304 89/<- %ebx 0/r32/eax +21305 # curr = curr->next +21306 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +21307 89/<- %edi 0/r32/eax +21308 # +21309 e9/jump loop/disp32 +21310 } +21311 # if curr is not null, abort +21312 81 7/subop/compare %edi 0/imm32 +21313 0f 85/jump-if-!= $check-mu-return-stmt:error-too-many-inouts/disp32 +21314 $check-mu-return-stmt:end: +21315 # . reclaim locals +21316 81 0/subop/add %esp 0x6c/imm32 +21317 # . restore registers +21318 5f/pop-to-edi +21319 5e/pop-to-esi +21320 5b/pop-to-ebx +21321 5a/pop-to-edx +21322 59/pop-to-ecx +21323 58/pop-to-eax +21324 # . epilogue +21325 89/<- %esp 5/r32/ebp +21326 5d/pop-to-ebp +21327 c3/return 21328 -21329 $check-mu-index-stmt:error-base-array-type-in-register: +21329 $check-mu-return-stmt:error1: 21330 (write-buffered *(ebp+0x10) "fn ") 21331 8b/-> *(ebp+0xc) 0/r32/eax 21332 (lookup *eax *(eax+4)) # Function-name Function-name => eax 21333 (write-buffered *(ebp+0x10) %eax) -21334 (write-buffered *(ebp+0x10) ": stmt index: var '") -21335 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21336 (write-buffered *(ebp+0x10) %eax) -21337 (write-buffered *(ebp+0x10) "' is an array, and so must live on the stack\n") -21338 (flush *(ebp+0x10)) -21339 (stop *(ebp+0x14) 1) -21340 # never gets here -21341 -21342 $check-mu-index-stmt:error-too-few-inouts: -21343 (write-buffered *(ebp+0x10) "fn ") -21344 8b/-> *(ebp+0xc) 0/r32/eax -21345 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21346 (write-buffered *(ebp+0x10) %eax) -21347 (write-buffered *(ebp+0x10) ": stmt index: too few inouts (2 required)\n") -21348 (flush *(ebp+0x10)) -21349 (stop *(ebp+0x14) 1) -21350 # never gets here -21351 -21352 $check-mu-index-stmt:error-invalid-index-type: -21353 (write-buffered *(ebp+0x10) "fn ") -21354 8b/-> *(ebp+0xc) 0/r32/eax -21355 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21356 (write-buffered *(ebp+0x10) %eax) -21357 (write-buffered *(ebp+0x10) ": stmt index: second argument '") -21358 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21359 (write-buffered *(ebp+0x10) %eax) -21360 (write-buffered *(ebp+0x10) "' must be an int or offset\n") -21361 (flush *(ebp+0x10)) -21362 (stop *(ebp+0x14) 1) -21363 # never gets here -21364 -21365 $check-mu-index-stmt:error-index-offset-atom-type: -21366 (write-buffered *(ebp+0x10) "fn ") -21367 8b/-> *(ebp+0xc) 0/r32/eax -21368 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21369 (write-buffered *(ebp+0x10) %eax) -21370 (write-buffered *(ebp+0x10) ": stmt index: offset '") -21371 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21372 (write-buffered *(ebp+0x10) %eax) -21373 (write-buffered *(ebp+0x10) "' must specify the type of array elements\n") -21374 (flush *(ebp+0x10)) -21375 (stop *(ebp+0x14) 1) -21376 # never gets here -21377 -21378 $check-mu-index-stmt:error-index-on-stack: -21379 (write-buffered *(ebp+0x10) "fn ") -21380 8b/-> *(ebp+0xc) 0/r32/eax -21381 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21382 (write-buffered *(ebp+0x10) %eax) -21383 (write-buffered *(ebp+0x10) ": stmt index: second argument '") -21384 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21385 (write-buffered *(ebp+0x10) %eax) -21386 (write-buffered *(ebp+0x10) "' must be in a register\n") -21387 (flush *(ebp+0x10)) -21388 (stop *(ebp+0x14) 1) -21389 # never gets here -21390 -21391 $check-mu-index-stmt:error-index-needs-offset: -21392 (write-buffered *(ebp+0x10) "fn ") -21393 8b/-> *(ebp+0xc) 0/r32/eax -21394 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21395 (write-buffered *(ebp+0x10) %eax) -21396 (write-buffered *(ebp+0x10) ": stmt index: cannot take an int for array '") -21397 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21398 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21399 (lookup *eax *(eax+4)) # Var-name Var-name => eax -21400 (write-buffered *(ebp+0x10) %eax) -21401 (write-buffered *(ebp+0x10) "'; create an offset instead. See mu.md for details.\n") -21402 (flush *(ebp+0x10)) -21403 (stop *(ebp+0x14) 1) -21404 # never gets here -21405 -21406 $check-mu-index-stmt:error-too-many-inouts: -21407 (write-buffered *(ebp+0x10) "fn ") -21408 8b/-> *(ebp+0xc) 0/r32/eax -21409 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21410 (write-buffered *(ebp+0x10) %eax) -21411 (write-buffered *(ebp+0x10) ": stmt index: too many inouts (2 required)\n") -21412 (flush *(ebp+0x10)) -21413 (stop *(ebp+0x14) 1) -21414 # never gets here -21415 -21416 $check-mu-index-stmt:error-too-few-outputs: -21417 (write-buffered *(ebp+0x10) "fn ") -21418 8b/-> *(ebp+0xc) 0/r32/eax -21419 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21420 (write-buffered *(ebp+0x10) %eax) -21421 (write-buffered *(ebp+0x10) ": stmt index: must have an output\n") -21422 (flush *(ebp+0x10)) -21423 (stop *(ebp+0x14) 1) -21424 # never gets here -21425 -21426 $check-mu-index-stmt:error-too-many-outputs: -21427 (write-buffered *(ebp+0x10) "fn ") -21428 8b/-> *(ebp+0xc) 0/r32/eax -21429 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21430 (write-buffered *(ebp+0x10) %eax) -21431 (write-buffered *(ebp+0x10) ": stmt index: too many outputs (1 required)\n") -21432 (flush *(ebp+0x10)) -21433 (stop *(ebp+0x14) 1) -21434 # never gets here -21435 -21436 $check-mu-index-stmt:error-output-not-in-register: -21437 (write-buffered *(ebp+0x10) "fn ") -21438 8b/-> *(ebp+0xc) 0/r32/eax -21439 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21440 (write-buffered *(ebp+0x10) %eax) -21441 (write-buffered *(ebp+0x10) ": stmt index: output '") -21442 (lookup *edi *(edi+4)) # Var-name Var-name => eax -21443 (write-buffered *(ebp+0x10) %eax) -21444 (write-buffered *(ebp+0x10) "' is not in a register\n") -21445 (flush *(ebp+0x10)) -21446 (stop *(ebp+0x14) 1) -21447 # never gets here -21448 -21449 $check-mu-index-stmt:error-output-type-not-address: -21450 (write-buffered *(ebp+0x10) "fn ") -21451 8b/-> *(ebp+0xc) 0/r32/eax -21452 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21453 (write-buffered *(ebp+0x10) %eax) -21454 (write-buffered *(ebp+0x10) ": stmt index: output '") -21455 (lookup *edi *(edi+4)) # Var-name Var-name => eax -21456 (write-buffered *(ebp+0x10) %eax) -21457 (write-buffered *(ebp+0x10) "' must be an addr\n") -21458 (flush *(ebp+0x10)) -21459 (stop *(ebp+0x14) 1) -21460 # never gets here -21461 -21462 $check-mu-index-stmt:error-bad-output-type: -21463 (write-buffered *(ebp+0x10) "fn ") -21464 8b/-> *(ebp+0xc) 0/r32/eax -21465 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21466 (write-buffered *(ebp+0x10) %eax) -21467 (write-buffered *(ebp+0x10) ": stmt index: output '") -21468 (lookup *edi *(edi+4)) # Var-name Var-name => eax -21469 (write-buffered *(ebp+0x10) %eax) -21470 (write-buffered *(ebp+0x10) "' does not have the right type\n") -21471 (flush *(ebp+0x10)) -21472 (stop *(ebp+0x14) 1) -21473 # never gets here -21474 -21475 check-mu-length-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -21476 # . prologue -21477 55/push-ebp -21478 89/<- %ebp 4/r32/esp -21479 # . save registers -21480 50/push-eax -21481 51/push-ecx -21482 52/push-edx -21483 53/push-ebx -21484 56/push-esi -21485 57/push-edi -21486 # esi = stmt -21487 8b/-> *(ebp+8) 6/r32/esi -21488 # - check for 0 inouts -21489 # var base/ecx: (addr var) = stmt->inouts->value -21490 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21491 $check-mu-length-stmt:check-no-inouts: -21492 3d/compare-eax-and 0/imm32 -21493 0f 84/jump-if-= $check-mu-length-stmt:error-too-few-inouts/disp32 -21494 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21495 89/<- %ecx 0/r32/eax -21496 # - check base type is either (addr array ...) in register or (array ...) on stack -21497 # var base-type/ebx: (addr type-tree) = lookup(base->type) -21498 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -21499 89/<- %ebx 0/r32/eax -21500 # if base-type is an atom, abort with a precise error -21501 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -21502 { -21503 74/jump-if-= break/disp8 -21504 (is-simple-mu-type? %ebx 3) # array => eax -21505 3d/compare-eax-and 0/imm32/false -21506 0f 85/jump-if-!= $check-mu-length-stmt:error-base-array-atom-type/disp32 -21507 0f 84/jump-if-= $check-mu-length-stmt:error-base-non-array-type/disp32 -21508 } -21509 $check-mu-length-stmt:base-is-compound: -21510 # if type->left not addr or array, abort -21511 { -21512 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21513 (is-simple-mu-type? %eax 2) # addr => eax -21514 3d/compare-eax-and 0/imm32/false -21515 75/jump-if-!= break/disp8 -21516 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21517 (is-simple-mu-type? %eax 3) # array => eax -21518 3d/compare-eax-and 0/imm32/false -21519 75/jump-if-!= break/disp8 -21520 e9/jump $check-mu-length-stmt:error-base-non-array-type/disp32 -21521 } -21522 # if (type->left == addr) ensure type->right->left == array and type->register exists -21523 { -21524 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21525 (is-simple-mu-type? %eax 2) # addr => eax -21526 3d/compare-eax-and 0/imm32/false -21527 74/jump-if-= break/disp8 -21528 $check-mu-length-stmt:base-is-addr: -21529 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -21530 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -21531 (is-simple-mu-type? %eax 3) # array => eax -21532 3d/compare-eax-and 0/imm32/false -21533 0f 84/jump-if-= $check-mu-length-stmt:error-base-non-array-type/disp32 -21534 $check-mu-length-stmt:check-base-addr-is-register: -21535 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -21536 0f 84/jump-if-= $check-mu-length-stmt:error-base-address-array-type-on-stack/disp32 -21537 } -21538 # if (type->left == array) ensure type->register doesn't exist -21539 { -21540 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21541 (is-simple-mu-type? %eax 3) # array => eax -21542 3d/compare-eax-and 0/imm32/false -21543 74/jump-if-= break/disp8 -21544 $check-mu-length-stmt:base-is-array: -21545 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -21546 0f 85/jump-if-!= $check-mu-length-stmt:error-base-array-type-in-register/disp32 -21547 } -21548 # if (base-type->left == addr) base-type = base-type->right -21549 { -21550 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21551 (is-simple-mu-type? %eax 2) # addr => eax -21552 3d/compare-eax-and 0/imm32/false -21553 74/jump-if-= break/disp8 -21554 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -21555 89/<- %ebx 0/r32/eax -21556 } -21557 # - check for too many inouts -21558 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21559 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21560 3d/compare-eax-and 0/imm32/false -21561 0f 85/jump-if-!= $check-mu-length-stmt:error-too-many-inouts/disp32 -21562 # - check for 0 outputs -21563 # var output/edi: (addr var) = stmt->outputs->value -21564 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -21565 3d/compare-eax-and 0/imm32/false -21566 0f 84/jump-if-= $check-mu-length-stmt:error-too-few-outputs/disp32 -21567 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21568 89/<- %edi 0/r32/eax -21569 # - check output type -21570 # must have a non-atomic type -21571 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -21572 (is-simple-mu-type? %eax 1) # int => eax -21573 3d/compare-eax-and 0/imm32/false -21574 0f 84/jump-if-= $check-mu-length-stmt:error-invalid-output-type/disp32 -21575 # - check for too many outputs -21576 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -21577 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21578 3d/compare-eax-and 0/imm32/false -21579 0f 85/jump-if-!= $check-mu-length-stmt:error-too-many-outputs/disp32 -21580 $check-mu-length-stmt:end: -21581 # . restore registers -21582 5f/pop-to-edi -21583 5e/pop-to-esi -21584 5b/pop-to-ebx -21585 5a/pop-to-edx -21586 59/pop-to-ecx -21587 58/pop-to-eax -21588 # . epilogue -21589 89/<- %esp 5/r32/ebp -21590 5d/pop-to-ebp -21591 c3/return -21592 -21593 $check-mu-length-stmt:error-base-non-array-type: -21594 (write-buffered *(ebp+0x10) "fn ") -21595 8b/-> *(ebp+0xc) 0/r32/eax -21596 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21597 (write-buffered *(ebp+0x10) %eax) -21598 (write-buffered *(ebp+0x10) ": stmt length: var '") -21599 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21600 (write-buffered *(ebp+0x10) %eax) -21601 (write-buffered *(ebp+0x10) "' is not an array\n") -21602 (flush *(ebp+0x10)) -21603 (stop *(ebp+0x14) 1) -21604 # never gets here -21605 -21606 $check-mu-length-stmt:error-base-array-atom-type: -21607 (write-buffered *(ebp+0x10) "fn ") -21608 8b/-> *(ebp+0xc) 0/r32/eax -21609 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21610 (write-buffered *(ebp+0x10) %eax) -21611 (write-buffered *(ebp+0x10) ": stmt length: array '") -21612 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21613 (write-buffered *(ebp+0x10) %eax) -21614 (write-buffered *(ebp+0x10) "' must specify the type of its elements\n") -21615 (flush *(ebp+0x10)) -21616 (stop *(ebp+0x14) 1) -21617 # never gets here -21618 -21619 $check-mu-length-stmt:error-base-address-array-type-on-stack: -21620 (write-buffered *(ebp+0x10) "fn ") -21621 8b/-> *(ebp+0xc) 0/r32/eax -21622 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21623 (write-buffered *(ebp+0x10) %eax) -21624 (write-buffered *(ebp+0x10) ": stmt length: var '") -21625 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21626 (write-buffered *(ebp+0x10) %eax) -21627 (write-buffered *(ebp+0x10) "' is an addr to an array, and so must live in a register\n") -21628 (flush *(ebp+0x10)) -21629 (stop *(ebp+0x14) 1) -21630 # never gets here +21334 (write-buffered *(ebp+0x10) ": return: '") +21335 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +21336 (lookup *eax *(eax+4)) # Var-name Var-name => eax +21337 (write-buffered *(ebp+0x10) %eax) +21338 (write-buffered *(ebp+0x10) "' has the wrong type\n") +21339 (flush *(ebp+0x10)) +21340 (stop *(ebp+0x14) 1) +21341 # never gets here +21342 +21343 $check-mu-return-stmt:error2: +21344 (write-buffered *(ebp+0x10) "fn ") +21345 8b/-> *(ebp+0xc) 0/r32/eax +21346 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21347 (write-buffered *(ebp+0x10) %eax) +21348 (write-buffered *(ebp+0x10) ": return: '") +21349 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +21350 (lookup *eax *(eax+4)) # Var-name Var-name => eax +21351 (write-buffered *(ebp+0x10) %eax) +21352 (write-buffered *(ebp+0x10) "' is no longer available\n") +21353 (flush *(ebp+0x10)) +21354 (stop *(ebp+0x14) 1) +21355 # never gets here +21356 +21357 $check-mu-return-stmt:error-too-few-inouts: +21358 (write-buffered *(ebp+0x10) "fn ") +21359 8b/-> *(ebp+0xc) 0/r32/eax +21360 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21361 (write-buffered *(ebp+0x10) %eax) +21362 (write-buffered *(ebp+0x10) ": return: too few inouts\n") +21363 (flush *(ebp+0x10)) +21364 (stop *(ebp+0x14) 1) +21365 # never gets here +21366 +21367 $check-mu-return-stmt:error-too-many-inouts: +21368 (write-buffered *(ebp+0x10) "fn ") +21369 8b/-> *(ebp+0xc) 0/r32/eax +21370 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21371 (write-buffered *(ebp+0x10) %eax) +21372 (write-buffered *(ebp+0x10) ": return: too many inouts\n") +21373 (flush *(ebp+0x10)) +21374 (stop *(ebp+0x14) 1) +21375 # never gets here +21376 +21377 check-all-unique-registers: # outputs: (addr list var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +21378 # . prologue +21379 55/push-ebp +21380 89/<- %ebp 4/r32/esp +21381 # . save registers +21382 50/push-eax +21383 51/push-ecx +21384 56/push-esi +21385 # var table/esi: (addr table (handle array byte) int 8) +21386 81 5/subop/subtract %esp 0x60/imm32 +21387 68/push 0x60/imm32/size +21388 68/push 0/imm32/read +21389 68/push 0/imm32/write +21390 89/<- %esi 4/r32/esp +21391 # var curr/ecx: (addr list var) = outputs +21392 8b/-> *(ebp+8) 1/r32/ecx +21393 { +21394 # if (curr == 0) break +21395 81 7/subop/compare %ecx 0/imm32 +21396 0f 84/jump-if-= break/disp32 +21397 # var reg/eax: (addr array byte) = curr->value->register # guaranteed to exist +21398 (lookup *ecx *(ecx+4)) # List-value List-value => eax +21399 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +21400 # if reg exists in table, abort +21401 (maybe-get %esi %eax 0xc) # => eax +21402 3d/compare-eax-and 0/imm32 +21403 0f 85/jump-if-!= $check-all-unique-registers:abort/disp32 +21404 # insert reg in table +21405 (lookup *ecx *(ecx+4)) # List-value List-value => eax +21406 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +21407 (get-or-insert %esi %eax 0xc Heap) +21408 # curr = curr->next +21409 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +21410 89/<- %ecx 0/r32/eax +21411 e9/jump loop/disp32 +21412 } +21413 $check-all-unique-registers:end: +21414 # . reclaim locals +21415 81 0/subop/add %esp 0x6c/imm32 +21416 # . restore registers +21417 5e/pop-to-esi +21418 59/pop-to-ecx +21419 58/pop-to-eax +21420 # . epilogue +21421 89/<- %esp 5/r32/ebp +21422 5d/pop-to-ebp +21423 c3/return +21424 +21425 $check-all-unique-registers:abort: +21426 (write-buffered *(ebp+0x10) "fn ") +21427 8b/-> *(ebp+0xc) 0/r32/eax +21428 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21429 (write-buffered *(ebp+0x10) %eax) +21430 (write-buffered *(ebp+0x10) ": outputs must be in unique registers\n") +21431 (flush *(ebp+0x10)) +21432 (stop *(ebp+0x14) 1) +21433 # never gets here +21434 +21435 # return false if s's register is not between start (inclusive) and end (exclusive) +21436 # return false if the positionally corresponding register in stmt->inouts (where s comes from) is also s's register +21437 # otherwise return true +21438 register-within-list-with-conflict?: # s: (addr stmt-var), start: (addr list var), end: (addr list var), stmt: (addr stmt) -> result/eax: boolean +21439 # . prologue +21440 55/push-ebp +21441 89/<- %ebp 4/r32/esp +21442 # . save registers +21443 51/push-ecx +21444 52/push-edx +21445 53/push-ebx +21446 56/push-esi +21447 57/push-edi +21448 # var target/ebx: (addr array byte) = s->value->register +21449 8b/-> *(ebp+8) 0/r32/eax +21450 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +21451 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +21452 #? (write-buffered Stderr "AA: ") +21453 #? (write-buffered Stderr %eax) +21454 #? (write-buffered Stderr Newline) +21455 #? (flush Stderr) +21456 # if (var->register == 0) return false +21457 3d/compare-eax-and 0/imm32 +21458 0f 84/jump-if-= $register-within-list-with-conflict?:end/disp32 # eax turns into result +21459 89/<- %ebx 0/r32/eax +21460 # var curr/ecx: (addr list var) = start +21461 8b/-> *(ebp+0xc) 1/r32/ecx +21462 # edx = end +21463 8b/-> *(ebp+0x10) 2/r32/edx +21464 { +21465 # if (curr == 0) break +21466 81 7/subop/compare %edi 0/imm32 +21467 0f 84/jump-if-= break/disp32 +21468 # if (curr == end) break +21469 39/compare %ecx 2/r32/edx +21470 0f 84/jump-if-= break/disp32 +21471 # var curr-reg/eax: (addr array byte) = curr->value->register +21472 (lookup *ecx *(ecx+4)) # List-value List-value => eax +21473 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +21474 # if (curr-reg == 0) continue +21475 3d/compare-eax-and 0/imm32 +21476 74/jump-if-= $register-within-list-with-conflict?:continue/disp8 +21477 # if (curr-reg == target) check for conflict +21478 (string-equal? %eax %ebx) # => eax +21479 3d/compare-eax-and 0/imm32/false +21480 { +21481 74/jump-if-= break/disp8 +21482 #? (write-buffered Stderr "conflict?\n") +21483 #? (flush Stderr) +21484 # var return-inouts/eax: (addr stmt-var) = stmt->inouts +21485 8b/-> *(ebp+0x14) 0/r32/eax +21486 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax +21487 (register-conflict? %ebx %eax *(ebp+0xc)) # => eax +21488 eb/jump $register-within-list-with-conflict?:end/disp8 +21489 } +21490 $register-within-list-with-conflict?:continue: +21491 # curr = curr->next +21492 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +21493 89/<- %ecx 0/r32/eax +21494 e9/jump loop/disp32 +21495 } +21496 # return false +21497 b8/copy-to-eax 0/imm32/false +21498 $register-within-list-with-conflict?:end: +21499 # . restore registers +21500 5f/pop-to-edi +21501 5e/pop-to-esi +21502 5b/pop-to-ebx +21503 5a/pop-to-edx +21504 59/pop-to-ecx +21505 # . epilogue +21506 89/<- %esp 5/r32/ebp +21507 5d/pop-to-ebp +21508 c3/return +21509 +21510 # At the first occurrence of register 'reg' in fn-outputs, +21511 # check if the corresponding element of return-inouts has a different register. +21512 # This hacky helper is intended to be called in one specific place. Don't +21513 # reuse it as is. +21514 register-conflict?: # reg: (addr array byte), return-inouts: (addr stmt-var), fn-outputs: (addr list var) => result/eax: boolean +21515 # . prologue +21516 55/push-ebp +21517 89/<- %ebp 4/r32/esp +21518 # . save registers +21519 51/push-ecx +21520 52/push-edx +21521 53/push-ebx +21522 56/push-esi +21523 57/push-edi +21524 #? (write-buffered Stderr "BB: ") +21525 #? (write-buffered Stderr *(ebp+8)) +21526 #? (write-buffered Stderr Newline) +21527 #? (flush Stderr) +21528 # var curr-output/edi: (addr list var) = fn-outputs +21529 8b/-> *(ebp+0x10) 7/r32/edi +21530 # var curr-inout/esi: (addr stmt-var) = return-inouts +21531 8b/-> *(ebp+0xc) 6/r32/esi +21532 { +21533 # if (curr-output == 0) abort +21534 81 7/subop/compare %edi 0/imm32 +21535 0f 84/jump-if-= break/disp32 +21536 # if (curr-output->value->register != reg) continue +21537 (lookup *edi *(edi+4)) # List-value List-value => eax +21538 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +21539 (string-equal? %eax *(ebp+8)) # => eax +21540 3d/compare-eax-and 0/imm32/false +21541 0f 84/jump-if= $register-conflict?:continue/disp32 +21542 #? (write-buffered Stderr "rescan\n") +21543 #? (flush Stderr) +21544 # var curr-reg/eax: (addr array byte) = curr-inout->value->register +21545 (lookup *esi *(esi+4)) # List-value List-value => eax +21546 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +21547 # if (curr-reg == 0) return true +21548 3d/compare-eax-and 0/imm32 +21549 { +21550 75/jump-if-!= break/disp8 +21551 #? (write-buffered Stderr "no register\n") +21552 #? (flush Stderr) +21553 b8/copy-to-eax 1/imm32/true +21554 e9/jump $register-conflict?:end/disp32 +21555 } +21556 # return (curr-reg != reg) +21557 (string-equal? %eax *(ebp+8)) # => eax +21558 3d/compare-eax-and 0/imm32/false +21559 0f 94/set-if-= %al +21560 #? (write-buffered Stderr "final: ") +21561 #? (write-int32-hex-buffered Stderr %eax) +21562 #? (write-buffered Stderr Newline) +21563 #? (flush Stderr) +21564 eb/jump $register-conflict?:end/disp8 +21565 $register-conflict?:continue: +21566 # curr-output = curr-output->next +21567 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax +21568 89/<- %edi 0/r32/eax +21569 # curr-inout = curr-inout->next +21570 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +21571 89/<- %esi 0/r32/eax +21572 e9/jump loop/disp32 +21573 } +21574 # should never get here +21575 (write-buffered Stderr "register-conflict? misused\n") +21576 (flush Stderr) +21577 e8/call syscall_exit/disp32 +21578 $register-conflict?:end: +21579 # . restore registers +21580 5f/pop-to-edi +21581 5e/pop-to-esi +21582 5b/pop-to-ebx +21583 5a/pop-to-edx +21584 59/pop-to-ecx +21585 # . epilogue +21586 89/<- %esp 5/r32/ebp +21587 5d/pop-to-ebp +21588 c3/return +21589 +21590 check-final-stmt-is-return: # block: (addr block), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +21591 # . prologue +21592 55/push-ebp +21593 89/<- %ebp 4/r32/esp +21594 # . save registers +21595 50/push-eax +21596 51/push-ecx +21597 # var curr/ecx: (addr list stmt) = block->stmts +21598 8b/-> *(ebp+8) 0/r32/eax +21599 (lookup *(eax+4) *(eax+8)) # Block-stmts Block-stmts => eax +21600 3d/compare-eax-and 0/imm32 +21601 74/jump-if-= $check-final-stmt-is-return:end/disp8 +21602 89/<- %ecx 0/r32/eax +21603 { +21604 # if curr->next == 0, break +21605 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +21606 3d/compare-eax-and 0/imm32 +21607 74/jump-if-= break/disp8 +21608 # curr = curr->next +21609 89/<- %ecx 0/r32/eax +21610 e9/jump loop/disp32 +21611 } +21612 $check-final-stmt-is-return:check-tag: +21613 # if curr->value->tag != Stmt1, abort +21614 (lookup *ecx *(ecx+4)) # List-value List-value => eax +21615 81 7/subop/compare *eax 1/imm32/stmt1 # Stmt-tag +21616 75/jump-if-!= $check-final-stmt-is-return:error/disp8 +21617 $check-final-stmt-is-return:check-operation: +21618 # if curr->operation != "return", abort +21619 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +21620 (string-equal? %eax "return") +21621 3d/compare-eax-and 0/imm32/false +21622 74/jump-if-= $check-final-stmt-is-return:error/disp8 +21623 $check-final-stmt-is-return:end: +21624 # . restore registers +21625 59/pop-to-ecx +21626 58/pop-to-eax +21627 # . epilogue +21628 89/<- %esp 5/r32/ebp +21629 5d/pop-to-ebp +21630 c3/return 21631 -21632 $check-mu-length-stmt:error-base-array-type-in-register: +21632 $check-final-stmt-is-return:error: 21633 (write-buffered *(ebp+0x10) "fn ") 21634 8b/-> *(ebp+0xc) 0/r32/eax 21635 (lookup *eax *(eax+4)) # Function-name Function-name => eax 21636 (write-buffered *(ebp+0x10) %eax) -21637 (write-buffered *(ebp+0x10) ": stmt length: var '") -21638 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21639 (write-buffered *(ebp+0x10) %eax) -21640 (write-buffered *(ebp+0x10) "' is an array, and so must live on the stack\n") -21641 (flush *(ebp+0x10)) -21642 (stop *(ebp+0x14) 1) -21643 # never gets here -21644 -21645 $check-mu-length-stmt:error-too-few-inouts: -21646 (write-buffered *(ebp+0x10) "fn ") -21647 8b/-> *(ebp+0xc) 0/r32/eax -21648 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21649 (write-buffered *(ebp+0x10) %eax) -21650 (write-buffered *(ebp+0x10) ": stmt length: too few inouts (1 required)\n") -21651 (flush *(ebp+0x10)) -21652 (stop *(ebp+0x14) 1) -21653 # never gets here -21654 -21655 $check-mu-length-stmt:error-invalid-index-type: -21656 (write-buffered *(ebp+0x10) "fn ") -21657 8b/-> *(ebp+0xc) 0/r32/eax -21658 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21659 (write-buffered *(ebp+0x10) %eax) -21660 (write-buffered *(ebp+0x10) ": stmt length: second argument '") -21661 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21662 (write-buffered *(ebp+0x10) %eax) -21663 (write-buffered *(ebp+0x10) "' must be an int or offset\n") -21664 (flush *(ebp+0x10)) -21665 (stop *(ebp+0x14) 1) -21666 # never gets here -21667 -21668 $check-mu-length-stmt:error-index-offset-atom-type: -21669 (write-buffered *(ebp+0x10) "fn ") -21670 8b/-> *(ebp+0xc) 0/r32/eax -21671 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21672 (write-buffered *(ebp+0x10) %eax) -21673 (write-buffered *(ebp+0x10) ": stmt length: offset '") -21674 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21675 (write-buffered *(ebp+0x10) %eax) -21676 (write-buffered *(ebp+0x10) "' must specify the type of array elements\n") -21677 (flush *(ebp+0x10)) -21678 (stop *(ebp+0x14) 1) -21679 # never gets here -21680 -21681 $check-mu-length-stmt:error-index-on-stack: -21682 (write-buffered *(ebp+0x10) "fn ") -21683 8b/-> *(ebp+0xc) 0/r32/eax -21684 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21685 (write-buffered *(ebp+0x10) %eax) -21686 (write-buffered *(ebp+0x10) ": stmt length: second argument '") -21687 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +21637 (write-buffered *(ebp+0x10) ": final statement should be a 'return'\n") +21638 (flush *(ebp+0x10)) +21639 (stop *(ebp+0x14) 1) +21640 # never gets here +21641 +21642 check-no-breaks: # block: (addr block), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +21643 # . prologue +21644 55/push-ebp +21645 89/<- %ebp 4/r32/esp +21646 # . save registers +21647 50/push-eax +21648 51/push-ecx +21649 # var curr/ecx: (addr list stmt) = block->stmts +21650 8b/-> *(ebp+8) 0/r32/eax +21651 (lookup *(eax+4) *(eax+8)) # Block-stmts Block-stmts => eax +21652 3d/compare-eax-and 0/imm32 +21653 0f 84/jump-if-= $check-no-breaks:end/disp32 +21654 89/<- %ecx 0/r32/eax +21655 { +21656 # if curr->next == 0, break +21657 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +21658 3d/compare-eax-and 0/imm32 +21659 74/jump-if-= break/disp8 +21660 # if curr->value->tag != Stmt1, continue +21661 (lookup *ecx *(ecx+4)) # List-value List-value => eax +21662 81 7/subop/compare *eax 1/imm32/stmt1 # Stmt-tag +21663 75/jump-if-!= $check-no-breaks:continue/disp8 +21664 # if curr->value->operation starts with "break", abort +21665 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +21666 (string-starts-with? %eax "break") # => eax +21667 3d/compare-eax-and 0/imm32/false +21668 75/jump-if-!= $check-no-breaks:error/disp8 +21669 $check-no-breaks:continue: +21670 # curr = curr->next +21671 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +21672 89/<- %ecx 0/r32/eax +21673 e9/jump loop/disp32 +21674 } +21675 $check-no-breaks:end: +21676 # . restore registers +21677 59/pop-to-ecx +21678 58/pop-to-eax +21679 # . epilogue +21680 89/<- %esp 5/r32/ebp +21681 5d/pop-to-ebp +21682 c3/return +21683 +21684 $check-no-breaks:error: +21685 (write-buffered *(ebp+0x10) "fn ") +21686 8b/-> *(ebp+0xc) 0/r32/eax +21687 (lookup *eax *(eax+4)) # Function-name Function-name => eax 21688 (write-buffered *(ebp+0x10) %eax) -21689 (write-buffered *(ebp+0x10) "' must be in a register\n") +21689 (write-buffered *(ebp+0x10) " has outputs, so you cannot 'break' out of the outermost block. Use 'return'.\n") 21690 (flush *(ebp+0x10)) 21691 (stop *(ebp+0x14) 1) 21692 # never gets here 21693 -21694 $check-mu-length-stmt:error-index-needs-offset: -21695 (write-buffered *(ebp+0x10) "fn ") -21696 8b/-> *(ebp+0xc) 0/r32/eax -21697 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21698 (write-buffered *(ebp+0x10) %eax) -21699 (write-buffered *(ebp+0x10) ": stmt length: cannot take an int for array '") -21700 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21701 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21702 (lookup *eax *(eax+4)) # Var-name Var-name => eax -21703 (write-buffered *(ebp+0x10) %eax) -21704 (write-buffered *(ebp+0x10) "'; create an offset instead. See mu.md for details.\n") -21705 (flush *(ebp+0x10)) -21706 (stop *(ebp+0x14) 1) -21707 # never gets here -21708 -21709 $check-mu-length-stmt:error-too-many-inouts: -21710 (write-buffered *(ebp+0x10) "fn ") -21711 8b/-> *(ebp+0xc) 0/r32/eax -21712 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21713 (write-buffered *(ebp+0x10) %eax) -21714 (write-buffered *(ebp+0x10) ": stmt length: too many inouts (1 required)\n") -21715 (flush *(ebp+0x10)) -21716 (stop *(ebp+0x14) 1) -21717 # never gets here -21718 -21719 $check-mu-length-stmt:error-too-few-outputs: -21720 (write-buffered *(ebp+0x10) "fn ") -21721 8b/-> *(ebp+0xc) 0/r32/eax -21722 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21723 (write-buffered *(ebp+0x10) %eax) -21724 (write-buffered *(ebp+0x10) ": stmt length: must have an output\n") -21725 (flush *(ebp+0x10)) -21726 (stop *(ebp+0x14) 1) -21727 # never gets here -21728 -21729 $check-mu-length-stmt:error-too-many-outputs: -21730 (write-buffered *(ebp+0x10) "fn ") -21731 8b/-> *(ebp+0xc) 0/r32/eax -21732 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21733 (write-buffered *(ebp+0x10) %eax) -21734 (write-buffered *(ebp+0x10) ": stmt length: too many outputs (1 required)\n") -21735 (flush *(ebp+0x10)) -21736 (stop *(ebp+0x14) 1) -21737 # never gets here -21738 -21739 $check-mu-length-stmt:error-output-not-in-register: -21740 (write-buffered *(ebp+0x10) "fn ") -21741 8b/-> *(ebp+0xc) 0/r32/eax -21742 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21743 (write-buffered *(ebp+0x10) %eax) -21744 (write-buffered *(ebp+0x10) ": stmt length: output '") -21745 (lookup *edi *(edi+4)) # Var-name Var-name => eax -21746 (write-buffered *(ebp+0x10) %eax) -21747 (write-buffered *(ebp+0x10) "' is not in a register\n") -21748 (flush *(ebp+0x10)) -21749 (stop *(ebp+0x14) 1) -21750 # never gets here -21751 -21752 $check-mu-length-stmt:error-invalid-output-type: -21753 (write-buffered *(ebp+0x10) "fn ") -21754 8b/-> *(ebp+0xc) 0/r32/eax -21755 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21756 (write-buffered *(ebp+0x10) %eax) -21757 (write-buffered *(ebp+0x10) ": stmt length: output '") -21758 (lookup *edi *(edi+4)) # Var-name Var-name => eax -21759 (write-buffered *(ebp+0x10) %eax) -21760 (write-buffered *(ebp+0x10) "' does not have the right type\n") -21761 (flush *(ebp+0x10)) -21762 (stop *(ebp+0x14) 1) -21763 # never gets here -21764 -21765 check-mu-compute-offset-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -21766 # . prologue -21767 55/push-ebp -21768 89/<- %ebp 4/r32/esp -21769 # . save registers -21770 50/push-eax -21771 51/push-ecx -21772 52/push-edx -21773 53/push-ebx -21774 56/push-esi -21775 57/push-edi -21776 # esi = stmt -21777 8b/-> *(ebp+8) 6/r32/esi -21778 # - check for 0 inouts -21779 # var base/ecx: (addr var) = stmt->inouts->value -21780 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21781 $check-mu-compute-offset-stmt:check-no-inouts: -21782 3d/compare-eax-and 0/imm32 -21783 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-too-few-inouts/disp32 -21784 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21785 89/<- %ecx 0/r32/eax -21786 # - check base type is either (addr array ...) in register or (array ...) on stack -21787 # var base-type/ebx: (addr type-tree) = lookup(base->type) -21788 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -21789 89/<- %ebx 0/r32/eax -21790 # if base-type is an atom, abort with a precise error -21791 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -21792 { -21793 74/jump-if-= break/disp8 -21794 (is-simple-mu-type? %ebx 3) # array => eax -21795 3d/compare-eax-and 0/imm32/false -21796 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-base-array-atom-type/disp32 -21797 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-base-non-array-type/disp32 -21798 } -21799 $check-mu-compute-offset-stmt:base-is-compound: -21800 # if type->left not addr or array, abort -21801 { -21802 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21803 (is-simple-mu-type? %eax 2) # addr => eax -21804 3d/compare-eax-and 0/imm32/false -21805 75/jump-if-!= break/disp8 -21806 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21807 (is-simple-mu-type? %eax 3) # array => eax -21808 3d/compare-eax-and 0/imm32/false -21809 75/jump-if-!= break/disp8 -21810 e9/jump $check-mu-compute-offset-stmt:error-base-non-array-type/disp32 -21811 } -21812 # if (type->left == addr) ensure type->right->left == array and type->register exists -21813 { -21814 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21815 (is-simple-mu-type? %eax 2) # addr => eax -21816 3d/compare-eax-and 0/imm32/false -21817 74/jump-if-= break/disp8 -21818 $check-mu-compute-offset-stmt:base-is-addr: -21819 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -21820 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -21821 (is-simple-mu-type? %eax 3) # array => eax -21822 3d/compare-eax-and 0/imm32/false -21823 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-base-non-array-type/disp32 -21824 } -21825 # if (base-type->left == addr) base-type = base-type->right -21826 { -21827 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -21828 (is-simple-mu-type? %eax 2) # addr => eax -21829 3d/compare-eax-and 0/imm32/false -21830 74/jump-if-= break/disp8 -21831 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -21832 89/<- %ebx 0/r32/eax -21833 } -21834 # - check for 1 inout -21835 # var index/ecx: (addr stmt-var) = stmt->inouts->next->value -21836 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21837 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21838 $check-mu-compute-offset-stmt:check-single-inout: -21839 3d/compare-eax-and 0/imm32 -21840 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-too-few-inouts/disp32 -21841 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21842 89/<- %ecx 0/r32/eax -21843 # - check index is either a literal or register -21844 # var index-type/edx: (addr type-tree) -21845 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -21846 89/<- %edx 0/r32/eax -21847 # index type must be a literal or int -21848 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom -21849 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-invalid-index-type/disp32 -21850 { -21851 $check-mu-compute-offset-stmt:index-type-is-atom: -21852 (is-simple-mu-type? %edx 0) # literal => eax -21853 3d/compare-eax-and 0/imm32/false -21854 75/jump-if-!= break/disp8 -21855 (is-simple-mu-type? %edx 1) # int => eax -21856 3d/compare-eax-and 0/imm32/false -21857 75/jump-if-!= break/disp8 -21858 e9/jump $check-mu-compute-offset-stmt:error-invalid-index-type/disp32 -21859 } -21860 # - check for too many inouts -21861 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -21862 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21863 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21864 3d/compare-eax-and 0/imm32/false -21865 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-too-many-inouts/disp32 -21866 # - check for 0 outputs -21867 # var output/edi: (addr var) = stmt->outputs->value -21868 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -21869 3d/compare-eax-and 0/imm32/false -21870 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-too-few-outputs/disp32 -21871 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -21872 89/<- %edi 0/r32/eax -21873 # - check output type -21874 # must have a non-atomic type -21875 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -21876 89/<- %edx 0/r32/eax -21877 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom -21878 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-output-type-not-offset/disp32 -21879 # type must start with (offset ...) -21880 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -21881 (is-simple-mu-type? %eax 7) # offset => eax -21882 3d/compare-eax-and 0/imm32/false -21883 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-output-type-not-offset/disp32 -21884 # if tail(base-type) != tail(output-type) abort -21885 (type-tail %ebx) # => eax -21886 89/<- %ebx 0/r32/eax -21887 (type-tail %edx) # => eax -21888 (type-equal? %ebx %eax) # => eax -21889 3d/compare-eax-and 0/imm32/false -21890 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-bad-output-type/disp32 -21891 # - check for too many outputs -21892 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -21893 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -21894 3d/compare-eax-and 0/imm32/false -21895 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-too-many-outputs/disp32 -21896 $check-mu-compute-offset-stmt:end: -21897 # . restore registers -21898 5f/pop-to-edi -21899 5e/pop-to-esi -21900 5b/pop-to-ebx -21901 5a/pop-to-edx -21902 59/pop-to-ecx -21903 58/pop-to-eax -21904 # . epilogue -21905 89/<- %esp 5/r32/ebp -21906 5d/pop-to-ebp -21907 c3/return -21908 -21909 $check-mu-compute-offset-stmt:error-base-non-array-type: -21910 (write-buffered *(ebp+0x10) "fn ") -21911 8b/-> *(ebp+0xc) 0/r32/eax -21912 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21913 (write-buffered *(ebp+0x10) %eax) -21914 (write-buffered *(ebp+0x10) ": stmt compute-offset: var '") -21915 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +21694 check-mu-get-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +21695 # . prologue +21696 55/push-ebp +21697 89/<- %ebp 4/r32/esp +21698 # . save registers +21699 50/push-eax +21700 51/push-ecx +21701 52/push-edx +21702 53/push-ebx +21703 56/push-esi +21704 57/push-edi +21705 # esi = stmt +21706 8b/-> *(ebp+8) 6/r32/esi +21707 # - check for 0 inouts +21708 # var base/ecx: (addr var) = stmt->inouts->value +21709 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +21710 3d/compare-eax-and 0/imm32/false +21711 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 +21712 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +21713 89/<- %ecx 0/r32/eax +21714 $check-mu-get-stmt:check-base: +21715 # - check base type +21716 # if it's an 'addr', check that it's in a register +21717 # var base-type/ebx: (addr type-tree) = lookup(base->type) +21718 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +21719 89/<- %ebx 0/r32/eax +21720 { +21721 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +21722 0f 85/jump-if-!= break/disp32 +21723 $check-mu-get-stmt:base-is-compound: +21724 # if (type->left != addr) break +21725 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +21726 (is-simple-mu-type? %eax 2) # addr => eax +21727 3d/compare-eax-and 0/imm32/false +21728 74/jump-if-= break/disp8 +21729 $check-mu-get-stmt:base-is-addr: +21730 # now check for register +21731 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +21732 0f 84/jump-if-= $check-mu-get-stmt:error-base-type-addr-but-not-register/disp32 +21733 $check-mu-get-stmt:base-is-addr-in-register: +21734 # type->left is now an addr; skip it +21735 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +21736 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +21737 0f 85/jump-if-!= $check-mu-get-stmt:error-bad-base/disp32 +21738 $check-mu-get-stmt:base-is-addr-to-atom-in-register: +21739 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21740 89/<- %ebx 0/r32/eax +21741 } +21742 $check-mu-get-stmt:check-base-typeinfo: +21743 # ensure type is a container +21744 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +21745 { +21746 75/jump-if-!= break/disp8 +21747 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +21748 89/<- %ebx 0/r32/eax +21749 } +21750 # var base-type-id/ebx: type-id = base-type->value +21751 8b/-> *(ebx+4) 3/r32/ebx # Type-tree-value +21752 (is-container? %ebx) # => eax +21753 3d/compare-eax-and 0/imm32/false +21754 0f 84/jump-if-= $check-mu-get-stmt:error-bad-base/disp32 +21755 # var base-typeinfo/edx: (addr typeinfo) = find-typeinfo(base-type-id) +21756 # . var container/ecx: (handle typeinfo) +21757 68/push 0/imm32 +21758 68/push 0/imm32 +21759 89/<- %ecx 4/r32/esp +21760 # . +21761 (find-typeinfo %ebx %ecx) +21762 (lookup *ecx *(ecx+4)) # => eax +21763 # . reclaim container +21764 81 0/subop/add %esp 8/imm32 +21765 # . +21766 89/<- %edx 0/r32/eax +21767 # var offset/ecx: (addr stmt-var) = stmt->inouts->next +21768 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +21769 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +21770 89/<- %ecx 0/r32/eax +21771 # - check for 1 inout +21772 3d/compare-eax-and 0/imm32/false +21773 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 +21774 # var offset/ecx: (addr var) = lookup(offset->value) +21775 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +21776 89/<- %ecx 0/r32/eax +21777 # - check for valid field +21778 81 7/subop/compare *(ecx+0x14) -1/imm32/uninitialized # Var-offset +21779 0f 84/jump-if-= $check-mu-get-stmt:error-bad-field/disp32 +21780 # - check for too many inouts +21781 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +21782 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +21783 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +21784 3d/compare-eax-and 0/imm32/false +21785 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-inouts/disp32 +21786 # var output/edi: (addr var) = stmt->outputs->value +21787 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +21788 # - check for 0 outputs +21789 3d/compare-eax-and 0/imm32/false +21790 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-outputs/disp32 +21791 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +21792 89/<- %edi 0/r32/eax +21793 $check-mu-get-stmt:check-output-type: +21794 # - check output type +21795 # must be in register +21796 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax +21797 3d/compare-eax-and 0/imm32 +21798 0f 84/jump-if-= $check-mu-get-stmt:error-output-not-in-register/disp32 +21799 # must have a non-atomic type +21800 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +21801 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +21802 0f 85/jump-if-!= $check-mu-get-stmt:error-output-type-not-address/disp32 +21803 # type must start with (addr ...) +21804 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21805 (is-simple-mu-type? %eax 2) # => eax +21806 3d/compare-eax-and 0/imm32/false +21807 0f 84/jump-if-= $check-mu-get-stmt:error-output-type-not-address/disp32 +21808 $check-mu-get-stmt:check-output-type-match: +21809 # payload of addr type must match 'type' definition +21810 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +21811 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +21812 # if (payload->right == null) payload = payload->left +21813 81 7/subop/compare *(eax+0xc) 0/imm32/null # Type-tree-right +21814 { +21815 75/jump-if-!= break/disp8 +21816 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +21817 } +21818 89/<- %edi 0/r32/eax +21819 # . var output-name/ecx: (addr array byte) +21820 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +21821 89/<- %ecx 0/r32/eax +21822 # . var base-typeinfo-entry/eax: (addr handle typeinfo-entry) +21823 (lookup *(edx+4) *(edx+8)) # Typeinfo-fields Typeinfo-fields => eax +21824 (get %eax %ecx 0x10) # => eax +21825 # . +21826 (lookup *eax *(eax+4)) # => eax +21827 (lookup *eax *(eax+4)) # Typeinfo-entry-input-var Typeinfo-entry-input-var => eax +21828 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +21829 # . +21830 (type-equal? %edi %eax) # => eax +21831 3d/compare-eax-and 0/imm32/false +21832 0f 84/jump-if-= $check-mu-get-stmt:error-bad-output-type/disp32 +21833 # - check for too many outputs +21834 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +21835 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +21836 3d/compare-eax-and 0/imm32/false +21837 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-outputs/disp32 +21838 $check-mu-get-stmt:end: +21839 # . restore registers +21840 5f/pop-to-edi +21841 5e/pop-to-esi +21842 5b/pop-to-ebx +21843 5a/pop-to-edx +21844 59/pop-to-ecx +21845 58/pop-to-eax +21846 # . epilogue +21847 89/<- %esp 5/r32/ebp +21848 5d/pop-to-ebp +21849 c3/return +21850 +21851 $check-mu-get-stmt:error-too-few-inouts: +21852 (write-buffered *(ebp+0x10) "fn ") +21853 8b/-> *(ebp+0xc) 0/r32/eax +21854 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21855 (write-buffered *(ebp+0x10) %eax) +21856 (write-buffered *(ebp+0x10) ": stmt get: too few inouts (2 required)\n") +21857 (flush *(ebp+0x10)) +21858 (stop *(ebp+0x14) 1) +21859 # never gets here +21860 +21861 $check-mu-get-stmt:error-too-many-inouts: +21862 (write-buffered *(ebp+0x10) "fn ") +21863 8b/-> *(ebp+0xc) 0/r32/eax +21864 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21865 (write-buffered *(ebp+0x10) %eax) +21866 (write-buffered *(ebp+0x10) ": stmt get: too many inouts (2 required)\n") +21867 (flush *(ebp+0x10)) +21868 (stop *(ebp+0x14) 1) +21869 # never gets here +21870 +21871 $check-mu-get-stmt:error-too-few-outputs: +21872 (write-buffered *(ebp+0x10) "fn ") +21873 8b/-> *(ebp+0xc) 0/r32/eax +21874 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21875 (write-buffered *(ebp+0x10) %eax) +21876 (write-buffered *(ebp+0x10) ": stmt get: must have an output\n") +21877 (flush *(ebp+0x10)) +21878 (stop *(ebp+0x14) 1) +21879 # never gets here +21880 +21881 $check-mu-get-stmt:error-too-many-outputs: +21882 (write-buffered *(ebp+0x10) "fn ") +21883 8b/-> *(ebp+0xc) 0/r32/eax +21884 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21885 (write-buffered *(ebp+0x10) %eax) +21886 (write-buffered *(ebp+0x10) ": stmt get: too many outputs (1 required)\n") +21887 (flush *(ebp+0x10)) +21888 (stop *(ebp+0x14) 1) +21889 # never gets here +21890 +21891 $check-mu-get-stmt:error-bad-base: +21892 # error("fn " fn ": stmt get: var '" base->name "' must have a 'type' definition\n") +21893 (write-buffered *(ebp+0x10) "fn ") +21894 8b/-> *(ebp+0xc) 0/r32/eax +21895 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21896 (write-buffered *(ebp+0x10) %eax) +21897 (write-buffered *(ebp+0x10) ": stmt get: var '") +21898 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +21899 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +21900 (lookup *eax *(eax+4)) # Var-name Var-name => eax +21901 (write-buffered *(ebp+0x10) %eax) +21902 (write-buffered *(ebp+0x10) "' must have a 'type' definition\n") +21903 (flush *(ebp+0x10)) +21904 (stop *(ebp+0x14) 1) +21905 # never gets here +21906 +21907 $check-mu-get-stmt:error-base-type-addr-but-not-register: +21908 (write-buffered *(ebp+0x10) "fn ") +21909 8b/-> *(ebp+0xc) 0/r32/eax +21910 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21911 (write-buffered *(ebp+0x10) %eax) +21912 (write-buffered *(ebp+0x10) ": stmt get: var '") +21913 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +21914 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +21915 (lookup *eax *(eax+4)) # Var-name Var-name => eax 21916 (write-buffered *(ebp+0x10) %eax) -21917 (write-buffered *(ebp+0x10) "' is not an array\n") +21917 (write-buffered *(ebp+0x10) "' is an 'addr' type, and so must live in a register\n") 21918 (flush *(ebp+0x10)) 21919 (stop *(ebp+0x14) 1) 21920 # never gets here 21921 -21922 $check-mu-compute-offset-stmt:error-base-array-atom-type: -21923 (write-buffered *(ebp+0x10) "fn ") -21924 8b/-> *(ebp+0xc) 0/r32/eax -21925 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21926 (write-buffered *(ebp+0x10) %eax) -21927 (write-buffered *(ebp+0x10) ": stmt compute-offset: array '") -21928 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21929 (write-buffered *(ebp+0x10) %eax) -21930 (write-buffered *(ebp+0x10) "' must specify the type of its elements\n") -21931 (flush *(ebp+0x10)) -21932 (stop *(ebp+0x14) 1) -21933 # never gets here -21934 -21935 $check-mu-compute-offset-stmt:error-too-few-inouts: -21936 (write-buffered *(ebp+0x10) "fn ") -21937 8b/-> *(ebp+0xc) 0/r32/eax -21938 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21939 (write-buffered *(ebp+0x10) %eax) -21940 (write-buffered *(ebp+0x10) ": stmt compute-offset: too few inouts (2 required)\n") -21941 (flush *(ebp+0x10)) -21942 (stop *(ebp+0x14) 1) -21943 # never gets here -21944 -21945 $check-mu-compute-offset-stmt:error-invalid-index-type: -21946 (write-buffered *(ebp+0x10) "fn ") -21947 8b/-> *(ebp+0xc) 0/r32/eax -21948 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21949 (write-buffered *(ebp+0x10) %eax) -21950 (write-buffered *(ebp+0x10) ": stmt compute-offset: second argument '") -21951 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21952 (write-buffered *(ebp+0x10) %eax) -21953 (write-buffered *(ebp+0x10) "' must be an int\n") -21954 (flush *(ebp+0x10)) -21955 (stop *(ebp+0x14) 1) -21956 # never gets here -21957 -21958 $check-mu-compute-offset-stmt:error-index-offset-atom-type: -21959 (write-buffered *(ebp+0x10) "fn ") -21960 8b/-> *(ebp+0xc) 0/r32/eax -21961 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21962 (write-buffered *(ebp+0x10) %eax) -21963 (write-buffered *(ebp+0x10) ": stmt compute-offset: offset '") -21964 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21965 (write-buffered *(ebp+0x10) %eax) -21966 (write-buffered *(ebp+0x10) "' must specify the type of array elements\n") -21967 (flush *(ebp+0x10)) -21968 (stop *(ebp+0x14) 1) -21969 # never gets here -21970 -21971 $check-mu-compute-offset-stmt:error-index-on-stack: -21972 (write-buffered *(ebp+0x10) "fn ") -21973 8b/-> *(ebp+0xc) 0/r32/eax -21974 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21975 (write-buffered *(ebp+0x10) %eax) -21976 (write-buffered *(ebp+0x10) ": stmt compute-offset: second argument '") -21977 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -21978 (write-buffered *(ebp+0x10) %eax) -21979 (write-buffered *(ebp+0x10) "' must be in a register\n") -21980 (flush *(ebp+0x10)) -21981 (stop *(ebp+0x14) 1) -21982 # never gets here -21983 -21984 $check-mu-compute-offset-stmt:error-too-many-inouts: -21985 (write-buffered *(ebp+0x10) "fn ") -21986 8b/-> *(ebp+0xc) 0/r32/eax -21987 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21988 (write-buffered *(ebp+0x10) %eax) -21989 (write-buffered *(ebp+0x10) ": stmt compute-offset: too many inouts (2 required)\n") -21990 (flush *(ebp+0x10)) -21991 (stop *(ebp+0x14) 1) -21992 # never gets here -21993 -21994 $check-mu-compute-offset-stmt:error-too-few-outputs: -21995 (write-buffered *(ebp+0x10) "fn ") -21996 8b/-> *(ebp+0xc) 0/r32/eax -21997 (lookup *eax *(eax+4)) # Function-name Function-name => eax -21998 (write-buffered *(ebp+0x10) %eax) -21999 (write-buffered *(ebp+0x10) ": stmt compute-offset: must have an output\n") -22000 (flush *(ebp+0x10)) -22001 (stop *(ebp+0x14) 1) -22002 # never gets here -22003 -22004 $check-mu-compute-offset-stmt:error-too-many-outputs: -22005 (write-buffered *(ebp+0x10) "fn ") -22006 8b/-> *(ebp+0xc) 0/r32/eax -22007 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22008 (write-buffered *(ebp+0x10) %eax) -22009 (write-buffered *(ebp+0x10) ": stmt compute-offset: too many outputs (1 required)\n") -22010 (flush *(ebp+0x10)) -22011 (stop *(ebp+0x14) 1) -22012 # never gets here -22013 -22014 $check-mu-compute-offset-stmt:error-output-not-in-register: -22015 (write-buffered *(ebp+0x10) "fn ") -22016 8b/-> *(ebp+0xc) 0/r32/eax -22017 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22018 (write-buffered *(ebp+0x10) %eax) -22019 (write-buffered *(ebp+0x10) ": stmt compute-offset: output '") -22020 (lookup *edi *(edi+4)) # Var-name Var-name => eax -22021 (write-buffered *(ebp+0x10) %eax) -22022 (write-buffered *(ebp+0x10) "' is not in a register\n") -22023 (flush *(ebp+0x10)) -22024 (stop *(ebp+0x14) 1) -22025 # never gets here -22026 -22027 $check-mu-compute-offset-stmt:error-output-type-not-offset: -22028 (write-buffered *(ebp+0x10) "fn ") -22029 8b/-> *(ebp+0xc) 0/r32/eax -22030 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22031 (write-buffered *(ebp+0x10) %eax) -22032 (write-buffered *(ebp+0x10) ": stmt compute-offset: output '") -22033 (lookup *edi *(edi+4)) # Var-name Var-name => eax -22034 (write-buffered *(ebp+0x10) %eax) -22035 (write-buffered *(ebp+0x10) "' must be an offset\n") -22036 (flush *(ebp+0x10)) -22037 (stop *(ebp+0x14) 1) -22038 # never gets here -22039 -22040 $check-mu-compute-offset-stmt:error-bad-output-type: -22041 (write-buffered *(ebp+0x10) "fn ") -22042 8b/-> *(ebp+0xc) 0/r32/eax -22043 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22044 (write-buffered *(ebp+0x10) %eax) -22045 (write-buffered *(ebp+0x10) ": stmt compute-offset: output '") -22046 (lookup *edi *(edi+4)) # Var-name Var-name => eax -22047 (write-buffered *(ebp+0x10) %eax) -22048 (write-buffered *(ebp+0x10) "' does not have the right type\n") -22049 (flush *(ebp+0x10)) -22050 (stop *(ebp+0x14) 1) -22051 # never gets here -22052 -22053 check-mu-copy-object-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -22054 # . prologue -22055 55/push-ebp -22056 89/<- %ebp 4/r32/esp -22057 # . save registers -22058 50/push-eax -22059 51/push-ecx -22060 53/push-ebx -22061 56/push-esi -22062 57/push-edi -22063 # esi = stmt -22064 8b/-> *(ebp+8) 6/r32/esi -22065 $check-mu-copy-object-stmt:check-for-output: -22066 # if stmt->outputs abort -22067 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -22068 3d/compare-eax-and 0/imm32 -22069 0f 85/jump-if-!= $check-mu-copy-object-stmt:error-too-many-outputs/disp32 -22070 $check-mu-copy-object-stmt:get-left: -22071 # var dest/edi: (addr stmt-var) = stmt->inouts -22072 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22073 89/<- %edi 0/r32/eax -22074 # zero inouts -22075 3d/compare-eax-and 0/imm32 -22076 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 -22077 $check-mu-copy-object-stmt:get-src: -22078 # var src/esi: (addr stmt-var) = dest->next -22079 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -22080 89/<- %esi 0/r32/eax -22081 # 1 inout -22082 3d/compare-eax-and 0/imm32 -22083 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 -22084 # > 2 inouts -22085 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -22086 3d/compare-eax-and 0/imm32 -22087 0f 85/jump-if-!= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 -22088 $check-mu-copy-object-stmt:types: -22089 # var src-type/ecx: (addr type-tree) = src->value->type -22090 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -22091 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -22092 89/<- %ecx 0/r32/eax -22093 # if (src->is-deref?) src-type = src-type->payload -22094 8b/-> *(esi+0x10) 0/r32/eax # Stmt-var-is-deref -22095 3d/compare-eax-and 0/imm32/false -22096 { -22097 74/jump-if-= break/disp8 -22098 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -22099 # if src-type->right is null, src-type = src-type->left -22100 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -22101 { -22102 75/jump-if-!= break/disp8 -22103 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -22104 } -22105 89/<- %ecx 0/r32/eax -22106 } -22107 # if src-type is not addr, abort -22108 (is-mu-addr-type? %ecx) # => eax -22109 3d/compare-eax-and 0/imm32/false -22110 0f 84/jump-if-= $check-mu-copy-object-stmt:error-invalid-types/disp32 -22111 # var dest-type/ebx: (addr type-tree) = dest->value->type -22112 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -22113 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -22114 89/<- %ebx 0/r32/eax -22115 # if (dest->is-deref?) dest-type = dest-type->payload -22116 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref -22117 3d/compare-eax-and 0/imm32/false -22118 { -22119 74/jump-if-= break/disp8 -22120 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22121 # if dest-type->right is null, dest-type = dest-type->left -22122 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -22123 { -22124 75/jump-if-!= break/disp8 -22125 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -22126 } -22127 89/<- %ebx 0/r32/eax -22128 } -22129 # if (dest-type != src-type) abort -22130 (type-equal? %ecx %ebx) # => eax -22131 3d/compare-eax-and 0/imm32 -22132 0f 84/jump-if-= $check-mu-copy-object-stmt:error-invalid-types/disp32 -22133 $check-mu-copy-object-stmt:end: -22134 # . restore registers -22135 5f/pop-to-edi -22136 5e/pop-to-esi -22137 5b/pop-to-ebx -22138 59/pop-to-ecx -22139 58/pop-to-eax -22140 # . epilogue -22141 89/<- %esp 5/r32/ebp -22142 5d/pop-to-ebp -22143 c3/return -22144 -22145 $check-mu-copy-object-stmt:error-incorrect-inouts: -22146 (write-buffered *(ebp+0x10) "fn ") -22147 8b/-> *(ebp+0xc) 0/r32/eax -22148 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22149 (write-buffered *(ebp+0x10) %eax) -22150 (write-buffered *(ebp+0x10) ": stmt 'copy-object' must have two inouts\n") -22151 (flush *(ebp+0x10)) -22152 (stop *(ebp+0x14) 1) -22153 # never gets here -22154 -22155 $check-mu-copy-object-stmt:error-too-many-outputs: -22156 (write-buffered *(ebp+0x10) "fn ") -22157 8b/-> *(ebp+0xc) 0/r32/eax -22158 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22159 (write-buffered *(ebp+0x10) %eax) -22160 (write-buffered *(ebp+0x10) ": stmt 'copy-object' must not have any outputs\n") -22161 (flush *(ebp+0x10)) -22162 (stop *(ebp+0x14) 1) -22163 # never gets here -22164 -22165 $check-mu-copy-object-stmt:error-invalid-types: -22166 (write-buffered *(ebp+0x10) "fn ") -22167 8b/-> *(ebp+0xc) 0/r32/eax -22168 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22169 (write-buffered *(ebp+0x10) %eax) -22170 (write-buffered *(ebp+0x10) ": stmt copy-object: two inouts with identical addr types expected\n") -22171 (flush *(ebp+0x10)) -22172 (stop *(ebp+0x14) 1) -22173 # never gets here -22174 -22175 check-mu-allocate-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -22176 # . prologue -22177 55/push-ebp -22178 89/<- %ebp 4/r32/esp -22179 # . save registers -22180 50/push-eax -22181 53/push-ebx -22182 56/push-esi -22183 57/push-edi -22184 # esi = stmt -22185 8b/-> *(ebp+8) 6/r32/esi -22186 $check-mu-allocate-stmt:check-for-output: -22187 # if stmt->outputs abort -22188 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -22189 3d/compare-eax-and 0/imm32 -22190 0f 85/jump-if-!= $check-mu-allocate-stmt:error-too-many-outputs/disp32 -22191 $check-mu-allocate-stmt:get-target: -22192 # var target/edi: (addr stmt-var) = stmt->inouts -22193 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22194 89/<- %edi 0/r32/eax -22195 # zero inouts -22196 3d/compare-eax-and 0/imm32 -22197 0f 84/jump-if-= $check-mu-allocate-stmt:error-incorrect-inouts/disp32 -22198 # > 1 inouts -22199 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -22200 3d/compare-eax-and 0/imm32 -22201 0f 85/jump-if-!= $check-mu-allocate-stmt:error-incorrect-inouts/disp32 -22202 $check-mu-allocate-stmt:check-type: -22203 # var target-type/ebx: (addr type-tree) = target->value->type -22204 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -22205 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -22206 89/<- %ebx 0/r32/eax -22207 # if (target->is-deref?) target-type = target-type->payload -22208 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref -22209 3d/compare-eax-and 0/imm32/false -22210 { -22211 74/jump-if-= break/disp8 -22212 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22213 # if target-type->right is null, target-type = target-type->left -22214 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -22215 { -22216 75/jump-if-!= break/disp8 -22217 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -22218 } -22219 89/<- %ebx 0/r32/eax -22220 } -22221 # if target-type is not addr, abort -22222 (is-mu-addr-type? %ebx) # => eax -22223 3d/compare-eax-and 0/imm32/false -22224 0f 84/jump-if-= $check-mu-allocate-stmt:error-invalid-type/disp32 -22225 # if target-type->right is an atom, abort -22226 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22227 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -22228 0f 85/jump-if-!= $check-mu-allocate-stmt:error-invalid-type/disp32 -22229 # if target-type->right->left is not handle, abort -22230 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -22231 (is-simple-mu-type? %eax 4) # handle => eax -22232 3d/compare-eax-and 0/imm32/false -22233 0f 84/jump-if-= $check-mu-allocate-stmt:error-invalid-type/disp32 -22234 $check-mu-allocate-stmt:end: -22235 # . restore registers -22236 5f/pop-to-edi -22237 5e/pop-to-esi -22238 5b/pop-to-ebx -22239 58/pop-to-eax -22240 # . epilogue -22241 89/<- %esp 5/r32/ebp -22242 5d/pop-to-ebp -22243 c3/return -22244 -22245 $check-mu-allocate-stmt:error-incorrect-inouts: -22246 (write-buffered *(ebp+0x10) "fn ") -22247 8b/-> *(ebp+0xc) 0/r32/eax -22248 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22249 (write-buffered *(ebp+0x10) %eax) -22250 (write-buffered *(ebp+0x10) ": stmt 'allocate' must have a single inout\n") -22251 (flush *(ebp+0x10)) -22252 (stop *(ebp+0x14) 1) -22253 # never gets here -22254 -22255 $check-mu-allocate-stmt:error-too-many-outputs: -22256 (write-buffered *(ebp+0x10) "fn ") -22257 8b/-> *(ebp+0xc) 0/r32/eax -22258 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22259 (write-buffered *(ebp+0x10) %eax) -22260 (write-buffered *(ebp+0x10) ": stmt 'allocate' must not have any outputs\n") -22261 (flush *(ebp+0x10)) -22262 (stop *(ebp+0x14) 1) -22263 # never gets here -22264 -22265 $check-mu-allocate-stmt:error-invalid-type: -22266 (write-buffered *(ebp+0x10) "fn ") -22267 8b/-> *(ebp+0xc) 0/r32/eax -22268 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21922 $check-mu-get-stmt:error-bad-field: +21923 # error("fn " fn ": stmt get: type " type " has no member called '" curr->name "'\n") +21924 (write-buffered *(ebp+0x10) "fn ") +21925 8b/-> *(ebp+0xc) 0/r32/eax +21926 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21927 (write-buffered *(ebp+0x10) %eax) +21928 (write-buffered *(ebp+0x10) ": stmt get: type '") +21929 # . write(Type-id->data[tmp]) +21930 bf/copy-to-edi Type-id/imm32 +21931 8b/-> *(edi+ebx<<2+0xc) 6/r32/esi +21932 { +21933 81 7/subop/compare %esi 0/imm32 +21934 74/jump-if-= break/disp8 +21935 (write-buffered *(ebp+0x10) %esi) +21936 } +21937 # . +21938 (write-buffered *(ebp+0x10) "' has no member called '") +21939 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +21940 (write-buffered *(ebp+0x10) %eax) +21941 (write-buffered *(ebp+0x10) "'\n") +21942 (flush *(ebp+0x10)) +21943 (stop *(ebp+0x14) 1) +21944 # never gets here +21945 +21946 $check-mu-get-stmt:error-output-not-in-register: +21947 (write-buffered *(ebp+0x10) "fn ") +21948 8b/-> *(ebp+0xc) 0/r32/eax +21949 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21950 (write-buffered *(ebp+0x10) %eax) +21951 (write-buffered *(ebp+0x10) ": stmt get: output '") +21952 (lookup *edi *(edi+4)) # Var-name Var-name => eax +21953 (write-buffered *(ebp+0x10) %eax) +21954 (write-buffered *(ebp+0x10) "' is not in a register\n") +21955 (flush *(ebp+0x10)) +21956 (stop *(ebp+0x14) 1) +21957 # never gets here +21958 +21959 $check-mu-get-stmt:error-output-type-not-address: +21960 (write-buffered *(ebp+0x10) "fn ") +21961 8b/-> *(ebp+0xc) 0/r32/eax +21962 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21963 (write-buffered *(ebp+0x10) %eax) +21964 (write-buffered *(ebp+0x10) ": stmt get: output must be an addr\n") +21965 (flush *(ebp+0x10)) +21966 (stop *(ebp+0x14) 1) +21967 # never gets here +21968 +21969 $check-mu-get-stmt:error-bad-output-type: +21970 (write-buffered *(ebp+0x10) "fn ") +21971 8b/-> *(ebp+0xc) 0/r32/eax +21972 (lookup *eax *(eax+4)) # Function-name Function-name => eax +21973 (write-buffered *(ebp+0x10) %eax) +21974 (write-buffered *(ebp+0x10) ": stmt get: wrong output type for member '") +21975 (write-buffered *(ebp+0x10) %ecx) +21976 (write-buffered *(ebp+0x10) "' of type '") +21977 bf/copy-to-edi Type-id/imm32 +21978 8b/-> *(edi+ebx<<2+0xc) 6/r32/esi +21979 { +21980 81 7/subop/compare %esi 0/imm32 +21981 74/jump-if-= break/disp8 +21982 (write-buffered *(ebp+0x10) %esi) +21983 } +21984 (write-buffered *(ebp+0x10) "'\n") +21985 (flush *(ebp+0x10)) +21986 (stop *(ebp+0x14) 1) +21987 # never gets here +21988 +21989 check-mu-index-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +21990 # . prologue +21991 55/push-ebp +21992 89/<- %ebp 4/r32/esp +21993 # . save registers +21994 50/push-eax +21995 51/push-ecx +21996 52/push-edx +21997 53/push-ebx +21998 56/push-esi +21999 57/push-edi +22000 # esi = stmt +22001 8b/-> *(ebp+8) 6/r32/esi +22002 # - check for 0 inouts +22003 # var base/ecx: (addr var) = stmt->inouts->value +22004 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22005 $check-mu-index-stmt:check-no-inouts: +22006 3d/compare-eax-and 0/imm32 +22007 0f 84/jump-if-= $check-mu-index-stmt:error-too-few-inouts/disp32 +22008 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22009 89/<- %ecx 0/r32/eax +22010 # - check base type is either (addr array ...) in register or (array ...) on stack +22011 # var base-type/ebx: (addr type-tree) = lookup(base->type) +22012 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +22013 89/<- %ebx 0/r32/eax +22014 # if base-type is an atom, abort with a precise error +22015 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +22016 { +22017 74/jump-if-= break/disp8 +22018 (is-simple-mu-type? %ebx 3) # array => eax +22019 3d/compare-eax-and 0/imm32/false +22020 0f 85/jump-if-!= $check-mu-index-stmt:error-base-array-atom-type/disp32 +22021 0f 84/jump-if-= $check-mu-index-stmt:error-base-non-array-type/disp32 +22022 } +22023 $check-mu-index-stmt:base-is-compound: +22024 # if type->left not addr or array, abort +22025 { +22026 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22027 (is-simple-mu-type? %eax 2) # addr => eax +22028 3d/compare-eax-and 0/imm32/false +22029 75/jump-if-!= break/disp8 +22030 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22031 (is-simple-mu-type? %eax 3) # array => eax +22032 3d/compare-eax-and 0/imm32/false +22033 75/jump-if-!= break/disp8 +22034 e9/jump $check-mu-index-stmt:error-base-non-array-type/disp32 +22035 } +22036 # if (type->left == addr) ensure type->right->left == array and type->register exists +22037 { +22038 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22039 (is-simple-mu-type? %eax 2) # addr => eax +22040 3d/compare-eax-and 0/imm32/false +22041 74/jump-if-= break/disp8 +22042 $check-mu-index-stmt:base-is-addr: +22043 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +22044 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +22045 (is-simple-mu-type? %eax 3) # array => eax +22046 3d/compare-eax-and 0/imm32/false +22047 0f 84/jump-if-= $check-mu-index-stmt:error-base-non-array-type/disp32 +22048 $check-mu-index-stmt:check-base-addr-is-register: +22049 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +22050 0f 84/jump-if-= $check-mu-index-stmt:error-base-address-array-type-on-stack/disp32 +22051 } +22052 # if (type->left == array) ensure type->register doesn't exist +22053 { +22054 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22055 (is-simple-mu-type? %eax 3) # array => eax +22056 3d/compare-eax-and 0/imm32/false +22057 74/jump-if-= break/disp8 +22058 $check-mu-index-stmt:base-is-array: +22059 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +22060 0f 85/jump-if-!= $check-mu-index-stmt:error-base-array-type-in-register/disp32 +22061 } +22062 # if (base-type->left == addr) base-type = base-type->right +22063 { +22064 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22065 (is-simple-mu-type? %eax 2) # addr => eax +22066 3d/compare-eax-and 0/imm32/false +22067 74/jump-if-= break/disp8 +22068 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +22069 89/<- %ebx 0/r32/eax +22070 } +22071 # - check for 1 inout +22072 # var index/ecx: (addr stmt-var) = stmt->inouts->next->value +22073 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22074 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22075 $check-mu-index-stmt:check-single-inout: +22076 3d/compare-eax-and 0/imm32 +22077 0f 84/jump-if-= $check-mu-index-stmt:error-too-few-inouts/disp32 +22078 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22079 89/<- %ecx 0/r32/eax +22080 # - check index is either a literal or register +22081 # var index-type/edx: (addr type-tree) +22082 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +22083 89/<- %edx 0/r32/eax +22084 # if index type is an atom, it must be a literal or int +22085 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom +22086 { +22087 74/jump-if-= break/disp8 +22088 $check-mu-index-stmt:index-type-is-atom: +22089 (is-simple-mu-type? %edx 0) # literal => eax +22090 3d/compare-eax-and 0/imm32/false +22091 75/jump-if-!= $check-mu-index-stmt:index-type-done/disp8 +22092 (is-simple-mu-type? %edx 1) # int => eax +22093 3d/compare-eax-and 0/imm32/false +22094 75/jump-if-!= $check-mu-index-stmt:index-type-done/disp8 +22095 (is-simple-mu-type? %edx 7) # offset => eax +22096 3d/compare-eax-and 0/imm32/false +22097 0f 85/jump-if-!= $check-mu-index-stmt:error-index-offset-atom-type/disp32 +22098 e9/jump $check-mu-index-stmt:error-invalid-index-type/disp32 +22099 } +22100 # if index type is a non-atom: it must be an offset +22101 { +22102 75/jump-if-!= break/disp8 +22103 $check-mu-index-stmt:index-type-is-non-atom: +22104 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +22105 (is-simple-mu-type? %eax 7) # offset => eax +22106 3d/compare-eax-and 0/imm32/false +22107 0f 84/jump-if-= $check-mu-index-stmt:error-invalid-index-type/disp32 +22108 } +22109 $check-mu-index-stmt:index-type-done: +22110 # check index is either a literal or in a register +22111 { +22112 (is-simple-mu-type? %edx 0) # literal => eax +22113 3d/compare-eax-and 0/imm32/false +22114 75/jump-if-!= break/disp8 +22115 $check-mu-index-stmt:check-index-in-register: +22116 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +22117 0f 84/jump-if-= $check-mu-index-stmt:error-index-on-stack/disp32 +22118 } +22119 # - if index is an 'int', check that element type of base has size 1, 2, 4 or 8 bytes. +22120 { +22121 (is-simple-mu-type? %edx 1) # int => eax +22122 3d/compare-eax-and 0/imm32/false +22123 74/jump-if-= break/disp8 +22124 $check-mu-index-stmt:check-index-can-be-int: +22125 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22126 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22127 (array-element-size %eax) # => eax +22128 3d/compare-eax-and 1/imm32 +22129 74/jump-if-= break/disp8 +22130 3d/compare-eax-and 2/imm32 +22131 74/jump-if-= break/disp8 +22132 3d/compare-eax-and 4/imm32 +22133 74/jump-if-= break/disp8 +22134 3d/compare-eax-and 8/imm32 +22135 74/jump-if-= break/disp8 +22136 e9/jump $check-mu-index-stmt:error-index-needs-offset/disp32 +22137 } +22138 # - check for too many inouts +22139 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22140 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22141 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22142 3d/compare-eax-and 0/imm32/false +22143 0f 85/jump-if-!= $check-mu-index-stmt:error-too-many-inouts/disp32 +22144 # - check for 0 outputs +22145 # var output/edi: (addr var) = stmt->outputs->value +22146 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +22147 3d/compare-eax-and 0/imm32/false +22148 0f 84/jump-if-= $check-mu-index-stmt:error-too-few-outputs/disp32 +22149 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22150 89/<- %edi 0/r32/eax +22151 # - check output type +22152 # must have a non-atomic type +22153 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +22154 89/<- %edx 0/r32/eax +22155 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom +22156 0f 85/jump-if-!= $check-mu-index-stmt:error-output-type-not-address/disp32 +22157 # type must start with (addr ...) +22158 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +22159 (is-simple-mu-type? %eax 2) # addr => eax +22160 3d/compare-eax-and 0/imm32/false +22161 0f 84/jump-if-= $check-mu-index-stmt:error-output-type-not-address/disp32 +22162 # if tail(base-type) != tail(output-type) abort +22163 (type-tail %ebx) # => eax +22164 89/<- %ebx 0/r32/eax +22165 (type-tail %edx) # => eax +22166 (type-equal? %ebx %eax) # => eax +22167 3d/compare-eax-and 0/imm32/false +22168 0f 84/jump-if-= $check-mu-index-stmt:error-bad-output-type/disp32 +22169 # - check for too many outputs +22170 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +22171 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22172 3d/compare-eax-and 0/imm32/false +22173 0f 85/jump-if-!= $check-mu-index-stmt:error-too-many-outputs/disp32 +22174 $check-mu-index-stmt:end: +22175 # . restore registers +22176 5f/pop-to-edi +22177 5e/pop-to-esi +22178 5b/pop-to-ebx +22179 5a/pop-to-edx +22180 59/pop-to-ecx +22181 58/pop-to-eax +22182 # . epilogue +22183 89/<- %esp 5/r32/ebp +22184 5d/pop-to-ebp +22185 c3/return +22186 +22187 $check-mu-index-stmt:error-base-non-array-type: +22188 (write-buffered *(ebp+0x10) "fn ") +22189 8b/-> *(ebp+0xc) 0/r32/eax +22190 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22191 (write-buffered *(ebp+0x10) %eax) +22192 (write-buffered *(ebp+0x10) ": stmt index: var '") +22193 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22194 (write-buffered *(ebp+0x10) %eax) +22195 (write-buffered *(ebp+0x10) "' is not an array\n") +22196 (flush *(ebp+0x10)) +22197 (stop *(ebp+0x14) 1) +22198 # never gets here +22199 +22200 $check-mu-index-stmt:error-base-array-atom-type: +22201 (write-buffered *(ebp+0x10) "fn ") +22202 8b/-> *(ebp+0xc) 0/r32/eax +22203 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22204 (write-buffered *(ebp+0x10) %eax) +22205 (write-buffered *(ebp+0x10) ": stmt index: array '") +22206 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22207 (write-buffered *(ebp+0x10) %eax) +22208 (write-buffered *(ebp+0x10) "' must specify the type of its elements\n") +22209 (flush *(ebp+0x10)) +22210 (stop *(ebp+0x14) 1) +22211 # never gets here +22212 +22213 $check-mu-index-stmt:error-base-address-array-type-on-stack: +22214 (write-buffered *(ebp+0x10) "fn ") +22215 8b/-> *(ebp+0xc) 0/r32/eax +22216 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22217 (write-buffered *(ebp+0x10) %eax) +22218 (write-buffered *(ebp+0x10) ": stmt index: var '") +22219 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22220 (write-buffered *(ebp+0x10) %eax) +22221 (write-buffered *(ebp+0x10) "' is an addr to an array, and so must live in a register\n") +22222 (flush *(ebp+0x10)) +22223 (stop *(ebp+0x14) 1) +22224 # never gets here +22225 +22226 $check-mu-index-stmt:error-base-array-type-in-register: +22227 (write-buffered *(ebp+0x10) "fn ") +22228 8b/-> *(ebp+0xc) 0/r32/eax +22229 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22230 (write-buffered *(ebp+0x10) %eax) +22231 (write-buffered *(ebp+0x10) ": stmt index: var '") +22232 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22233 (write-buffered *(ebp+0x10) %eax) +22234 (write-buffered *(ebp+0x10) "' is an array, and so must live on the stack\n") +22235 (flush *(ebp+0x10)) +22236 (stop *(ebp+0x14) 1) +22237 # never gets here +22238 +22239 $check-mu-index-stmt:error-too-few-inouts: +22240 (write-buffered *(ebp+0x10) "fn ") +22241 8b/-> *(ebp+0xc) 0/r32/eax +22242 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22243 (write-buffered *(ebp+0x10) %eax) +22244 (write-buffered *(ebp+0x10) ": stmt index: too few inouts (2 required)\n") +22245 (flush *(ebp+0x10)) +22246 (stop *(ebp+0x14) 1) +22247 # never gets here +22248 +22249 $check-mu-index-stmt:error-invalid-index-type: +22250 (write-buffered *(ebp+0x10) "fn ") +22251 8b/-> *(ebp+0xc) 0/r32/eax +22252 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22253 (write-buffered *(ebp+0x10) %eax) +22254 (write-buffered *(ebp+0x10) ": stmt index: second argument '") +22255 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22256 (write-buffered *(ebp+0x10) %eax) +22257 (write-buffered *(ebp+0x10) "' must be an int or offset\n") +22258 (flush *(ebp+0x10)) +22259 (stop *(ebp+0x14) 1) +22260 # never gets here +22261 +22262 $check-mu-index-stmt:error-index-offset-atom-type: +22263 (write-buffered *(ebp+0x10) "fn ") +22264 8b/-> *(ebp+0xc) 0/r32/eax +22265 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22266 (write-buffered *(ebp+0x10) %eax) +22267 (write-buffered *(ebp+0x10) ": stmt index: offset '") +22268 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax 22269 (write-buffered *(ebp+0x10) %eax) -22270 (write-buffered *(ebp+0x10) ": stmt allocate: inout '") -22271 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -22272 (lookup *eax *(eax+4)) # Var-name Var-name => eax -22273 (write-buffered *(ebp+0x10) %eax) -22274 (write-buffered *(ebp+0x10) "' must have type (addr handle ...)\n") -22275 (flush *(ebp+0x10)) -22276 (stop *(ebp+0x14) 1) -22277 # never gets here -22278 -22279 check-mu-populate-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -22280 # . prologue -22281 55/push-ebp -22282 89/<- %ebp 4/r32/esp -22283 # . save registers -22284 50/push-eax -22285 53/push-ebx -22286 56/push-esi -22287 57/push-edi -22288 # esi = stmt -22289 8b/-> *(ebp+8) 6/r32/esi -22290 $check-mu-populate-stmt:check-for-output: -22291 # if stmt->outputs abort -22292 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -22293 3d/compare-eax-and 0/imm32 -22294 0f 85/jump-if-!= $check-mu-populate-stmt:error-too-many-outputs/disp32 -22295 $check-mu-populate-stmt:get-target: -22296 # var target/edi: (addr stmt-var) = stmt->inouts -22297 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22298 89/<- %edi 0/r32/eax -22299 # zero inouts -22300 3d/compare-eax-and 0/imm32 -22301 0f 84/jump-if-= $check-mu-populate-stmt:error-incorrect-inouts/disp32 -22302 $check-mu-populate-stmt:get-length: -22303 # var length/esi: (addr stmt-var) = dest->next -22304 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -22305 89/<- %esi 0/r32/eax -22306 # 1 inout -22307 3d/compare-eax-and 0/imm32 -22308 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 -22309 # > 2 inouts -22310 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -22311 3d/compare-eax-and 0/imm32 -22312 0f 85/jump-if-!= $check-mu-populate-stmt:error-incorrect-inouts/disp32 -22313 $check-mu-populate-stmt:check-target-type: -22314 # var target-type/ebx: (addr type-tree) = target->value->type -22315 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -22316 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -22317 89/<- %ebx 0/r32/eax -22318 $check-mu-populate-stmt:check-target-type-deref: -22319 # if (target->is-deref?) target-type = target-type->payload -22320 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref -22321 3d/compare-eax-and 0/imm32/false -22322 { -22323 74/jump-if-= break/disp8 -22324 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22325 # if target-type->right is null, target-type = target-type->left -22326 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -22327 { -22328 75/jump-if-!= break/disp8 -22329 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -22330 } -22331 89/<- %ebx 0/r32/eax -22332 } -22333 $check-mu-populate-stmt:check-target-type-addr: -22334 # if target-type is not addr, abort -22335 (is-mu-addr-type? %ebx) # => eax -22336 3d/compare-eax-and 0/imm32/false -22337 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-target-type/disp32 -22338 # if target-type->right is an atom, abort -22339 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22340 89/<- %ebx 0/r32/eax -22341 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -22342 0f 85/jump-if-!= $check-mu-populate-stmt:error-invalid-target-type/disp32 -22343 $check-mu-populate-stmt:check-target-type-handle: -22344 # if target-type->right->left is not handle, abort -22345 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -22346 (is-simple-mu-type? %eax 4) # handle => eax -22347 3d/compare-eax-and 0/imm32/false -22348 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-target-type/disp32 -22349 # if target-type->right->right is an atom, abort -22350 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22351 89/<- %ebx 0/r32/eax -22352 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -22353 0f 85/jump-if-!= $check-mu-populate-stmt:error-invalid-target-type/disp32 -22354 $check-mu-populate-stmt:check-target-type-array: -22355 # if target-type->right->right->left is not array, abort -22356 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -22357 (is-simple-mu-type? %eax 3) # array => eax -22358 3d/compare-eax-and 0/imm32/false -22359 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-target-type/disp32 -22360 $check-mu-populate-stmt:check-length-type: -22361 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -22362 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -22363 89/<- %ebx 0/r32/eax -22364 (is-simple-mu-type? %ebx 0) # literal => eax -22365 3d/compare-eax-and 0/imm32/false -22366 75/jump-if-!= $check-mu-populate-stmt:end/disp8 -22367 (is-simple-mu-type? %ebx 1) # int => eax -22368 3d/compare-eax-and 0/imm32/false -22369 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-length-type/disp32 -22370 $check-mu-populate-stmt:end: -22371 # . restore registers -22372 5f/pop-to-edi -22373 5e/pop-to-esi -22374 5b/pop-to-ebx -22375 58/pop-to-eax -22376 # . epilogue -22377 89/<- %esp 5/r32/ebp -22378 5d/pop-to-ebp -22379 c3/return -22380 -22381 $check-mu-populate-stmt:error-incorrect-inouts: -22382 (write-buffered *(ebp+0x10) "fn ") -22383 8b/-> *(ebp+0xc) 0/r32/eax -22384 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22385 (write-buffered *(ebp+0x10) %eax) -22386 (write-buffered *(ebp+0x10) ": stmt 'populate' must have two inouts\n") -22387 (flush *(ebp+0x10)) -22388 (stop *(ebp+0x14) 1) -22389 # never gets here -22390 -22391 $check-mu-populate-stmt:error-too-many-outputs: -22392 (write-buffered *(ebp+0x10) "fn ") -22393 8b/-> *(ebp+0xc) 0/r32/eax -22394 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22395 (write-buffered *(ebp+0x10) %eax) -22396 (write-buffered *(ebp+0x10) ": stmt 'populate' must not have any outputs\n") -22397 (flush *(ebp+0x10)) -22398 (stop *(ebp+0x14) 1) -22399 # never gets here -22400 -22401 $check-mu-populate-stmt:error-invalid-target-type: -22402 (write-buffered *(ebp+0x10) "fn ") -22403 8b/-> *(ebp+0xc) 0/r32/eax -22404 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22405 (write-buffered *(ebp+0x10) %eax) -22406 (write-buffered *(ebp+0x10) ": stmt populate: first inout '") -22407 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -22408 (lookup *eax *(eax+4)) # Var-name Var-name => eax -22409 (write-buffered *(ebp+0x10) %eax) -22410 (write-buffered *(ebp+0x10) "' must have type (addr handle array ...)\n") -22411 (flush *(ebp+0x10)) -22412 (stop *(ebp+0x14) 1) -22413 # never gets here -22414 -22415 $check-mu-populate-stmt:error-invalid-length-type: -22416 (write-buffered *(ebp+0x10) "fn ") -22417 8b/-> *(ebp+0xc) 0/r32/eax -22418 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22419 (write-buffered *(ebp+0x10) %eax) -22420 (write-buffered *(ebp+0x10) ": stmt populate: second inout '") -22421 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -22422 (lookup *eax *(eax+4)) # Var-name Var-name => eax -22423 (write-buffered *(ebp+0x10) %eax) -22424 (write-buffered *(ebp+0x10) "' must be an int\n") -22425 (flush *(ebp+0x10)) -22426 (stop *(ebp+0x14) 1) -22427 # never gets here -22428 -22429 check-mu-populate-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -22430 # . prologue -22431 55/push-ebp -22432 89/<- %ebp 4/r32/esp -22433 # . save registers -22434 50/push-eax -22435 53/push-ebx -22436 56/push-esi -22437 57/push-edi -22438 # esi = stmt -22439 8b/-> *(ebp+8) 6/r32/esi -22440 $check-mu-populate-stream-stmt:check-for-output: -22441 # if stmt->outputs abort -22442 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -22443 3d/compare-eax-and 0/imm32 -22444 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-too-many-outputs/disp32 -22445 $check-mu-populate-stream-stmt:get-target: -22446 # var target/edi: (addr stmt-var) = stmt->inouts -22447 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22448 89/<- %edi 0/r32/eax -22449 # zero inouts -22450 3d/compare-eax-and 0/imm32 -22451 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-incorrect-inouts/disp32 -22452 $check-mu-populate-stream-stmt:get-length: -22453 # var length/esi: (addr stmt-var) = dest->next -22454 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -22455 89/<- %esi 0/r32/eax -22456 # 1 inout -22457 3d/compare-eax-and 0/imm32 -22458 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 -22459 # > 2 inouts -22460 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -22461 3d/compare-eax-and 0/imm32 -22462 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-incorrect-inouts/disp32 -22463 $check-mu-populate-stream-stmt:check-target-type: -22464 # var target-type/ebx: (addr type-tree) = target->value->type -22465 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -22466 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -22467 89/<- %ebx 0/r32/eax -22468 $check-mu-populate-stream-stmt:check-target-type-deref: -22469 # if (target->is-deref?) target-type = target-type->payload -22470 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref -22471 3d/compare-eax-and 0/imm32/false -22472 { -22473 74/jump-if-= break/disp8 -22474 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22475 # if target-type->right is null, target-type = target-type->left -22476 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right -22477 { -22478 75/jump-if-!= break/disp8 -22479 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -22480 } -22481 89/<- %ebx 0/r32/eax -22482 } -22483 $check-mu-populate-stream-stmt:check-target-type-addr: -22484 # if target-type is not addr, abort -22485 (is-mu-addr-type? %ebx) # => eax -22486 3d/compare-eax-and 0/imm32/false -22487 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 -22488 # if target-type->right is an atom, abort -22489 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22490 89/<- %ebx 0/r32/eax -22491 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -22492 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 -22493 $check-mu-populate-stream-stmt:check-target-type-handle: -22494 # if target-type->right->left is not handle, abort -22495 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -22496 (is-simple-mu-type? %eax 4) # handle => eax -22497 3d/compare-eax-and 0/imm32/false -22498 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 -22499 # if target-type->right->right is an atom, abort -22500 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22501 89/<- %ebx 0/r32/eax -22502 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -22503 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 -22504 $check-mu-populate-stream-stmt:check-target-type-stream: -22505 # if target-type->right->right->left is not stream, abort -22506 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -22507 (is-simple-mu-type? %eax 0xb) # stream => eax -22508 3d/compare-eax-and 0/imm32/false -22509 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 -22510 $check-mu-populate-stream-stmt:check-length-type: -22511 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -22512 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -22513 89/<- %ebx 0/r32/eax -22514 (is-simple-mu-type? %ebx 0) # literal => eax -22515 3d/compare-eax-and 0/imm32/false -22516 75/jump-if-!= $check-mu-populate-stream-stmt:end/disp8 -22517 (is-simple-mu-type? %ebx 1) # int => eax -22518 3d/compare-eax-and 0/imm32/false -22519 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-length-type/disp32 -22520 $check-mu-populate-stream-stmt:end: -22521 # . restore registers -22522 5f/pop-to-edi -22523 5e/pop-to-esi -22524 5b/pop-to-ebx -22525 58/pop-to-eax -22526 # . epilogue -22527 89/<- %esp 5/r32/ebp -22528 5d/pop-to-ebp -22529 c3/return -22530 -22531 $check-mu-populate-stream-stmt:error-incorrect-inouts: -22532 (write-buffered *(ebp+0x10) "fn ") -22533 8b/-> *(ebp+0xc) 0/r32/eax -22534 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22535 (write-buffered *(ebp+0x10) %eax) -22536 (write-buffered *(ebp+0x10) ": stmt 'populate-stream' must have two inouts\n") -22537 (flush *(ebp+0x10)) -22538 (stop *(ebp+0x14) 1) -22539 # never gets here -22540 -22541 $check-mu-populate-stream-stmt:error-too-many-outputs: -22542 (write-buffered *(ebp+0x10) "fn ") -22543 8b/-> *(ebp+0xc) 0/r32/eax -22544 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22545 (write-buffered *(ebp+0x10) %eax) -22546 (write-buffered *(ebp+0x10) ": stmt 'populate-stream' must not have any outputs\n") -22547 (flush *(ebp+0x10)) -22548 (stop *(ebp+0x14) 1) -22549 # never gets here -22550 -22551 $check-mu-populate-stream-stmt:error-invalid-target-type: -22552 (write-buffered *(ebp+0x10) "fn ") -22553 8b/-> *(ebp+0xc) 0/r32/eax -22554 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22555 (write-buffered *(ebp+0x10) %eax) -22556 (write-buffered *(ebp+0x10) ": stmt populate-stream: first inout '") -22557 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax -22558 (lookup *eax *(eax+4)) # Var-name Var-name => eax +22270 (write-buffered *(ebp+0x10) "' must specify the type of array elements\n") +22271 (flush *(ebp+0x10)) +22272 (stop *(ebp+0x14) 1) +22273 # never gets here +22274 +22275 $check-mu-index-stmt:error-index-on-stack: +22276 (write-buffered *(ebp+0x10) "fn ") +22277 8b/-> *(ebp+0xc) 0/r32/eax +22278 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22279 (write-buffered *(ebp+0x10) %eax) +22280 (write-buffered *(ebp+0x10) ": stmt index: second argument '") +22281 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22282 (write-buffered *(ebp+0x10) %eax) +22283 (write-buffered *(ebp+0x10) "' must be in a register\n") +22284 (flush *(ebp+0x10)) +22285 (stop *(ebp+0x14) 1) +22286 # never gets here +22287 +22288 $check-mu-index-stmt:error-index-needs-offset: +22289 (write-buffered *(ebp+0x10) "fn ") +22290 8b/-> *(ebp+0xc) 0/r32/eax +22291 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22292 (write-buffered *(ebp+0x10) %eax) +22293 (write-buffered *(ebp+0x10) ": stmt index: cannot take an int for array '") +22294 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22295 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22296 (lookup *eax *(eax+4)) # Var-name Var-name => eax +22297 (write-buffered *(ebp+0x10) %eax) +22298 (write-buffered *(ebp+0x10) "'; create an offset instead. See mu.md for details.\n") +22299 (flush *(ebp+0x10)) +22300 (stop *(ebp+0x14) 1) +22301 # never gets here +22302 +22303 $check-mu-index-stmt:error-too-many-inouts: +22304 (write-buffered *(ebp+0x10) "fn ") +22305 8b/-> *(ebp+0xc) 0/r32/eax +22306 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22307 (write-buffered *(ebp+0x10) %eax) +22308 (write-buffered *(ebp+0x10) ": stmt index: too many inouts (2 required)\n") +22309 (flush *(ebp+0x10)) +22310 (stop *(ebp+0x14) 1) +22311 # never gets here +22312 +22313 $check-mu-index-stmt:error-too-few-outputs: +22314 (write-buffered *(ebp+0x10) "fn ") +22315 8b/-> *(ebp+0xc) 0/r32/eax +22316 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22317 (write-buffered *(ebp+0x10) %eax) +22318 (write-buffered *(ebp+0x10) ": stmt index: must have an output\n") +22319 (flush *(ebp+0x10)) +22320 (stop *(ebp+0x14) 1) +22321 # never gets here +22322 +22323 $check-mu-index-stmt:error-too-many-outputs: +22324 (write-buffered *(ebp+0x10) "fn ") +22325 8b/-> *(ebp+0xc) 0/r32/eax +22326 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22327 (write-buffered *(ebp+0x10) %eax) +22328 (write-buffered *(ebp+0x10) ": stmt index: too many outputs (1 required)\n") +22329 (flush *(ebp+0x10)) +22330 (stop *(ebp+0x14) 1) +22331 # never gets here +22332 +22333 $check-mu-index-stmt:error-output-not-in-register: +22334 (write-buffered *(ebp+0x10) "fn ") +22335 8b/-> *(ebp+0xc) 0/r32/eax +22336 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22337 (write-buffered *(ebp+0x10) %eax) +22338 (write-buffered *(ebp+0x10) ": stmt index: output '") +22339 (lookup *edi *(edi+4)) # Var-name Var-name => eax +22340 (write-buffered *(ebp+0x10) %eax) +22341 (write-buffered *(ebp+0x10) "' is not in a register\n") +22342 (flush *(ebp+0x10)) +22343 (stop *(ebp+0x14) 1) +22344 # never gets here +22345 +22346 $check-mu-index-stmt:error-output-type-not-address: +22347 (write-buffered *(ebp+0x10) "fn ") +22348 8b/-> *(ebp+0xc) 0/r32/eax +22349 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22350 (write-buffered *(ebp+0x10) %eax) +22351 (write-buffered *(ebp+0x10) ": stmt index: output '") +22352 (lookup *edi *(edi+4)) # Var-name Var-name => eax +22353 (write-buffered *(ebp+0x10) %eax) +22354 (write-buffered *(ebp+0x10) "' must be an addr\n") +22355 (flush *(ebp+0x10)) +22356 (stop *(ebp+0x14) 1) +22357 # never gets here +22358 +22359 $check-mu-index-stmt:error-bad-output-type: +22360 (write-buffered *(ebp+0x10) "fn ") +22361 8b/-> *(ebp+0xc) 0/r32/eax +22362 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22363 (write-buffered *(ebp+0x10) %eax) +22364 (write-buffered *(ebp+0x10) ": stmt index: output '") +22365 (lookup *edi *(edi+4)) # Var-name Var-name => eax +22366 (write-buffered *(ebp+0x10) %eax) +22367 (write-buffered *(ebp+0x10) "' does not have the right type\n") +22368 (flush *(ebp+0x10)) +22369 (stop *(ebp+0x14) 1) +22370 # never gets here +22371 +22372 check-mu-length-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +22373 # . prologue +22374 55/push-ebp +22375 89/<- %ebp 4/r32/esp +22376 # . save registers +22377 50/push-eax +22378 51/push-ecx +22379 52/push-edx +22380 53/push-ebx +22381 56/push-esi +22382 57/push-edi +22383 # esi = stmt +22384 8b/-> *(ebp+8) 6/r32/esi +22385 # - check for 0 inouts +22386 # var base/ecx: (addr var) = stmt->inouts->value +22387 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22388 $check-mu-length-stmt:check-no-inouts: +22389 3d/compare-eax-and 0/imm32 +22390 0f 84/jump-if-= $check-mu-length-stmt:error-too-few-inouts/disp32 +22391 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22392 89/<- %ecx 0/r32/eax +22393 # - check base type is either (addr array ...) in register or (array ...) on stack +22394 # var base-type/ebx: (addr type-tree) = lookup(base->type) +22395 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +22396 89/<- %ebx 0/r32/eax +22397 # if base-type is an atom, abort with a precise error +22398 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +22399 { +22400 74/jump-if-= break/disp8 +22401 (is-simple-mu-type? %ebx 3) # array => eax +22402 3d/compare-eax-and 0/imm32/false +22403 0f 85/jump-if-!= $check-mu-length-stmt:error-base-array-atom-type/disp32 +22404 0f 84/jump-if-= $check-mu-length-stmt:error-base-non-array-type/disp32 +22405 } +22406 $check-mu-length-stmt:base-is-compound: +22407 # if type->left not addr or array, abort +22408 { +22409 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22410 (is-simple-mu-type? %eax 2) # addr => eax +22411 3d/compare-eax-and 0/imm32/false +22412 75/jump-if-!= break/disp8 +22413 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22414 (is-simple-mu-type? %eax 3) # array => eax +22415 3d/compare-eax-and 0/imm32/false +22416 75/jump-if-!= break/disp8 +22417 e9/jump $check-mu-length-stmt:error-base-non-array-type/disp32 +22418 } +22419 # if (type->left == addr) ensure type->right->left == array and type->register exists +22420 { +22421 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22422 (is-simple-mu-type? %eax 2) # addr => eax +22423 3d/compare-eax-and 0/imm32/false +22424 74/jump-if-= break/disp8 +22425 $check-mu-length-stmt:base-is-addr: +22426 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +22427 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +22428 (is-simple-mu-type? %eax 3) # array => eax +22429 3d/compare-eax-and 0/imm32/false +22430 0f 84/jump-if-= $check-mu-length-stmt:error-base-non-array-type/disp32 +22431 $check-mu-length-stmt:check-base-addr-is-register: +22432 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +22433 0f 84/jump-if-= $check-mu-length-stmt:error-base-address-array-type-on-stack/disp32 +22434 } +22435 # if (type->left == array) ensure type->register doesn't exist +22436 { +22437 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22438 (is-simple-mu-type? %eax 3) # array => eax +22439 3d/compare-eax-and 0/imm32/false +22440 74/jump-if-= break/disp8 +22441 $check-mu-length-stmt:base-is-array: +22442 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +22443 0f 85/jump-if-!= $check-mu-length-stmt:error-base-array-type-in-register/disp32 +22444 } +22445 # if (base-type->left == addr) base-type = base-type->right +22446 { +22447 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22448 (is-simple-mu-type? %eax 2) # addr => eax +22449 3d/compare-eax-and 0/imm32/false +22450 74/jump-if-= break/disp8 +22451 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +22452 89/<- %ebx 0/r32/eax +22453 } +22454 # - check for too many inouts +22455 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22456 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22457 3d/compare-eax-and 0/imm32/false +22458 0f 85/jump-if-!= $check-mu-length-stmt:error-too-many-inouts/disp32 +22459 # - check for 0 outputs +22460 # var output/edi: (addr var) = stmt->outputs->value +22461 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +22462 3d/compare-eax-and 0/imm32/false +22463 0f 84/jump-if-= $check-mu-length-stmt:error-too-few-outputs/disp32 +22464 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22465 89/<- %edi 0/r32/eax +22466 # - check output type +22467 # must have a non-atomic type +22468 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +22469 (is-simple-mu-type? %eax 1) # int => eax +22470 3d/compare-eax-and 0/imm32/false +22471 0f 84/jump-if-= $check-mu-length-stmt:error-invalid-output-type/disp32 +22472 # - check for too many outputs +22473 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +22474 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22475 3d/compare-eax-and 0/imm32/false +22476 0f 85/jump-if-!= $check-mu-length-stmt:error-too-many-outputs/disp32 +22477 $check-mu-length-stmt:end: +22478 # . restore registers +22479 5f/pop-to-edi +22480 5e/pop-to-esi +22481 5b/pop-to-ebx +22482 5a/pop-to-edx +22483 59/pop-to-ecx +22484 58/pop-to-eax +22485 # . epilogue +22486 89/<- %esp 5/r32/ebp +22487 5d/pop-to-ebp +22488 c3/return +22489 +22490 $check-mu-length-stmt:error-base-non-array-type: +22491 (write-buffered *(ebp+0x10) "fn ") +22492 8b/-> *(ebp+0xc) 0/r32/eax +22493 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22494 (write-buffered *(ebp+0x10) %eax) +22495 (write-buffered *(ebp+0x10) ": stmt length: var '") +22496 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22497 (write-buffered *(ebp+0x10) %eax) +22498 (write-buffered *(ebp+0x10) "' is not an array\n") +22499 (flush *(ebp+0x10)) +22500 (stop *(ebp+0x14) 1) +22501 # never gets here +22502 +22503 $check-mu-length-stmt:error-base-array-atom-type: +22504 (write-buffered *(ebp+0x10) "fn ") +22505 8b/-> *(ebp+0xc) 0/r32/eax +22506 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22507 (write-buffered *(ebp+0x10) %eax) +22508 (write-buffered *(ebp+0x10) ": stmt length: array '") +22509 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22510 (write-buffered *(ebp+0x10) %eax) +22511 (write-buffered *(ebp+0x10) "' must specify the type of its elements\n") +22512 (flush *(ebp+0x10)) +22513 (stop *(ebp+0x14) 1) +22514 # never gets here +22515 +22516 $check-mu-length-stmt:error-base-address-array-type-on-stack: +22517 (write-buffered *(ebp+0x10) "fn ") +22518 8b/-> *(ebp+0xc) 0/r32/eax +22519 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22520 (write-buffered *(ebp+0x10) %eax) +22521 (write-buffered *(ebp+0x10) ": stmt length: var '") +22522 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22523 (write-buffered *(ebp+0x10) %eax) +22524 (write-buffered *(ebp+0x10) "' is an addr to an array, and so must live in a register\n") +22525 (flush *(ebp+0x10)) +22526 (stop *(ebp+0x14) 1) +22527 # never gets here +22528 +22529 $check-mu-length-stmt:error-base-array-type-in-register: +22530 (write-buffered *(ebp+0x10) "fn ") +22531 8b/-> *(ebp+0xc) 0/r32/eax +22532 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22533 (write-buffered *(ebp+0x10) %eax) +22534 (write-buffered *(ebp+0x10) ": stmt length: var '") +22535 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22536 (write-buffered *(ebp+0x10) %eax) +22537 (write-buffered *(ebp+0x10) "' is an array, and so must live on the stack\n") +22538 (flush *(ebp+0x10)) +22539 (stop *(ebp+0x14) 1) +22540 # never gets here +22541 +22542 $check-mu-length-stmt:error-too-few-inouts: +22543 (write-buffered *(ebp+0x10) "fn ") +22544 8b/-> *(ebp+0xc) 0/r32/eax +22545 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22546 (write-buffered *(ebp+0x10) %eax) +22547 (write-buffered *(ebp+0x10) ": stmt length: too few inouts (1 required)\n") +22548 (flush *(ebp+0x10)) +22549 (stop *(ebp+0x14) 1) +22550 # never gets here +22551 +22552 $check-mu-length-stmt:error-invalid-index-type: +22553 (write-buffered *(ebp+0x10) "fn ") +22554 8b/-> *(ebp+0xc) 0/r32/eax +22555 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22556 (write-buffered *(ebp+0x10) %eax) +22557 (write-buffered *(ebp+0x10) ": stmt length: second argument '") +22558 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax 22559 (write-buffered *(ebp+0x10) %eax) -22560 (write-buffered *(ebp+0x10) "' must have type (addr handle stream ...)\n") +22560 (write-buffered *(ebp+0x10) "' must be an int or offset\n") 22561 (flush *(ebp+0x10)) 22562 (stop *(ebp+0x14) 1) 22563 # never gets here 22564 -22565 $check-mu-populate-stream-stmt:error-invalid-length-type: +22565 $check-mu-length-stmt:error-index-offset-atom-type: 22566 (write-buffered *(ebp+0x10) "fn ") 22567 8b/-> *(ebp+0xc) 0/r32/eax 22568 (lookup *eax *(eax+4)) # Function-name Function-name => eax 22569 (write-buffered *(ebp+0x10) %eax) -22570 (write-buffered *(ebp+0x10) ": stmt populate-stream: second inout '") -22571 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -22572 (lookup *eax *(eax+4)) # Var-name Var-name => eax -22573 (write-buffered *(ebp+0x10) %eax) -22574 (write-buffered *(ebp+0x10) "' must be an int\n") -22575 (flush *(ebp+0x10)) -22576 (stop *(ebp+0x14) 1) -22577 # never gets here -22578 -22579 check-mu-read-from-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -22580 # . prologue -22581 55/push-ebp -22582 89/<- %ebp 4/r32/esp -22583 # . save registers -22584 50/push-eax -22585 51/push-ecx -22586 52/push-edx -22587 53/push-ebx -22588 56/push-esi -22589 57/push-edi -22590 # esi = stmt -22591 8b/-> *(ebp+8) 6/r32/esi -22592 # - check for 0 inouts -22593 # var base/ecx: (addr var) = stmt->inouts->value -22594 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22595 $check-mu-read-from-stream-stmt:check-no-inouts: -22596 3d/compare-eax-and 0/imm32 -22597 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-too-few-inouts/disp32 +22570 (write-buffered *(ebp+0x10) ": stmt length: offset '") +22571 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22572 (write-buffered *(ebp+0x10) %eax) +22573 (write-buffered *(ebp+0x10) "' must specify the type of array elements\n") +22574 (flush *(ebp+0x10)) +22575 (stop *(ebp+0x14) 1) +22576 # never gets here +22577 +22578 $check-mu-length-stmt:error-index-on-stack: +22579 (write-buffered *(ebp+0x10) "fn ") +22580 8b/-> *(ebp+0xc) 0/r32/eax +22581 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22582 (write-buffered *(ebp+0x10) %eax) +22583 (write-buffered *(ebp+0x10) ": stmt length: second argument '") +22584 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22585 (write-buffered *(ebp+0x10) %eax) +22586 (write-buffered *(ebp+0x10) "' must be in a register\n") +22587 (flush *(ebp+0x10)) +22588 (stop *(ebp+0x14) 1) +22589 # never gets here +22590 +22591 $check-mu-length-stmt:error-index-needs-offset: +22592 (write-buffered *(ebp+0x10) "fn ") +22593 8b/-> *(ebp+0xc) 0/r32/eax +22594 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22595 (write-buffered *(ebp+0x10) %eax) +22596 (write-buffered *(ebp+0x10) ": stmt length: cannot take an int for array '") +22597 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax 22598 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -22599 89/<- %ecx 0/r32/eax -22600 # - check base type is (addr stream T) -22601 # var base-type/ebx: (addr type-tree) = lookup(base->type) -22602 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -22603 89/<- %ebx 0/r32/eax -22604 $check-mu-read-from-stream-stmt:check-base-is-compound: -22605 # if base-type is an atom, abort -22606 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -22607 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-invalid-base-type/disp32 -22608 $check-mu-read-from-stream-stmt:check-base-is-addr: -22609 # if type->left not addr, abort -22610 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -22611 (is-simple-mu-type? %eax 2) # addr => eax -22612 3d/compare-eax-and 0/imm32/false -22613 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-invalid-base-type/disp32 -22614 $check-mu-read-from-stream-stmt:check-base-is-addr-to-stream: -22615 # base-type = base-type->right -22616 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22617 89/<- %ebx 0/r32/eax -22618 # ensure base-type->left == stream -22619 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -22620 (is-simple-mu-type? %eax 0xb) # stream => eax -22621 3d/compare-eax-and 0/imm32/false -22622 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-invalid-base-type/disp32 -22623 # - check target type is (addr T) -22624 # var target/ecx: (addr stmt-var) = stmt->inouts->next->value -22625 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22626 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -22627 $check-mu-read-from-stream-stmt:check-single-inout: -22628 3d/compare-eax-and 0/imm32 -22629 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-too-few-inouts/disp32 -22630 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -22631 89/<- %ecx 0/r32/eax -22632 # var target-type/edx: (addr type-tree) -22633 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -22634 89/<- %edx 0/r32/eax -22635 # if target-type is an atom, it must be a literal or int -22636 $check-mu-read-from-stream-stmt:check-target-is-compound: -22637 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom -22638 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-target-type-not-address/disp32 -22639 $check-mu-read-from-stream-stmt:check-target-type: -22640 # target type must start with (addr ...) -22641 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -22642 (is-simple-mu-type? %eax 2) # addr => eax -22643 3d/compare-eax-and 0/imm32/false -22644 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-target-type-not-address/disp32 -22645 # if tail(base-type) != tail(target-type) abort -22646 (type-tail %ebx) # => eax -22647 89/<- %ebx 0/r32/eax -22648 (type-tail %edx) # => eax -22649 (type-equal? %ebx %eax) # => eax -22650 3d/compare-eax-and 0/imm32/false -22651 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-invalid-target-type/disp32 -22652 $check-mu-read-from-stream-stmt:check-too-many-inouts: -22653 # - check for too many inouts -22654 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22655 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -22656 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -22657 3d/compare-eax-and 0/imm32/false -22658 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-too-many-inouts/disp32 -22659 $check-mu-read-from-stream-stmt:check-unexpected-output: -22660 # - check for any output -22661 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -22662 3d/compare-eax-and 0/imm32/false -22663 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-unexpected-output/disp32 -22664 $check-mu-read-from-stream-stmt:end: -22665 # . restore registers -22666 5f/pop-to-edi -22667 5e/pop-to-esi -22668 5b/pop-to-ebx -22669 5a/pop-to-edx -22670 59/pop-to-ecx -22671 58/pop-to-eax -22672 # . epilogue -22673 89/<- %esp 5/r32/ebp -22674 5d/pop-to-ebp -22675 c3/return -22676 -22677 $check-mu-read-from-stream-stmt:error-invalid-base-type: -22678 (write-buffered *(ebp+0x10) "fn ") -22679 8b/-> *(ebp+0xc) 0/r32/eax -22680 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22681 (write-buffered *(ebp+0x10) %eax) -22682 (write-buffered *(ebp+0x10) ": stmt read-from-stream: var '") -22683 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -22684 (write-buffered *(ebp+0x10) %eax) -22685 (write-buffered *(ebp+0x10) "' must be an addr to a stream\n") -22686 (flush *(ebp+0x10)) -22687 (stop *(ebp+0x14) 1) -22688 # never gets here -22689 -22690 $check-mu-read-from-stream-stmt:error-too-few-inouts: -22691 (write-buffered *(ebp+0x10) "fn ") -22692 8b/-> *(ebp+0xc) 0/r32/eax -22693 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22694 (write-buffered *(ebp+0x10) %eax) -22695 (write-buffered *(ebp+0x10) ": stmt read-from-stream: too few inouts (2 required)\n") -22696 (flush *(ebp+0x10)) -22697 (stop *(ebp+0x14) 1) -22698 # never gets here -22699 -22700 $check-mu-read-from-stream-stmt:error-target-type-not-address: -22701 (write-buffered *(ebp+0x10) "fn ") -22702 8b/-> *(ebp+0xc) 0/r32/eax -22703 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22704 (write-buffered *(ebp+0x10) %eax) -22705 (write-buffered *(ebp+0x10) ": stmt read-from-stream: target '") -22706 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -22707 (write-buffered *(ebp+0x10) %eax) -22708 (write-buffered *(ebp+0x10) "' must be an addr\n") -22709 (flush *(ebp+0x10)) -22710 (stop *(ebp+0x14) 1) -22711 # never gets here -22712 -22713 $check-mu-read-from-stream-stmt:error-invalid-target-type: -22714 (write-buffered *(ebp+0x10) "fn ") -22715 8b/-> *(ebp+0xc) 0/r32/eax -22716 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22717 (write-buffered *(ebp+0x10) %eax) -22718 (write-buffered *(ebp+0x10) ": stmt read-from-stream: second inout '") -22719 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -22720 (write-buffered *(ebp+0x10) %eax) -22721 (write-buffered *(ebp+0x10) "' does not have the right type\n") -22722 (flush *(ebp+0x10)) -22723 (stop *(ebp+0x14) 1) -22724 # never gets here -22725 -22726 $check-mu-read-from-stream-stmt:error-too-many-inouts: -22727 (write-buffered *(ebp+0x10) "fn ") -22728 8b/-> *(ebp+0xc) 0/r32/eax -22729 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22730 (write-buffered *(ebp+0x10) %eax) -22731 (write-buffered *(ebp+0x10) ": stmt read-from-stream: too many inouts (2 required)\n") -22732 (flush *(ebp+0x10)) -22733 (stop *(ebp+0x14) 1) -22734 # never gets here -22735 -22736 $check-mu-read-from-stream-stmt:error-unexpected-output: -22737 (write-buffered *(ebp+0x10) "fn ") -22738 8b/-> *(ebp+0xc) 0/r32/eax -22739 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22740 (write-buffered *(ebp+0x10) %eax) -22741 (write-buffered *(ebp+0x10) ": stmt read-from-stream: unexpected output\n") -22742 (flush *(ebp+0x10)) -22743 (stop *(ebp+0x14) 1) -22744 # never gets here -22745 -22746 check-mu-write-to-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -22747 # . prologue -22748 55/push-ebp -22749 89/<- %ebp 4/r32/esp -22750 # . save registers -22751 50/push-eax -22752 51/push-ecx -22753 52/push-edx -22754 53/push-ebx -22755 56/push-esi -22756 57/push-edi -22757 # esi = stmt -22758 8b/-> *(ebp+8) 6/r32/esi -22759 # - check for 0 inouts -22760 # var base/ecx: (addr var) = stmt->inouts->value -22761 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22762 $check-mu-write-to-stream-stmt:check-no-inouts: -22763 3d/compare-eax-and 0/imm32 -22764 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-too-few-inouts/disp32 -22765 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -22766 89/<- %ecx 0/r32/eax -22767 # - check base type is (addr stream T) -22768 # var base-type/ebx: (addr type-tree) = lookup(base->type) -22769 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -22770 89/<- %ebx 0/r32/eax -22771 $check-mu-write-to-stream-stmt:check-base-is-compound: -22772 # if base-type is an atom, abort -22773 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom -22774 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-invalid-base-type/disp32 -22775 $check-mu-write-to-stream-stmt:check-base-is-addr: -22776 # if type->left not addr, abort -22777 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -22778 (is-simple-mu-type? %eax 2) # addr => eax +22599 (lookup *eax *(eax+4)) # Var-name Var-name => eax +22600 (write-buffered *(ebp+0x10) %eax) +22601 (write-buffered *(ebp+0x10) "'; create an offset instead. See mu.md for details.\n") +22602 (flush *(ebp+0x10)) +22603 (stop *(ebp+0x14) 1) +22604 # never gets here +22605 +22606 $check-mu-length-stmt:error-too-many-inouts: +22607 (write-buffered *(ebp+0x10) "fn ") +22608 8b/-> *(ebp+0xc) 0/r32/eax +22609 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22610 (write-buffered *(ebp+0x10) %eax) +22611 (write-buffered *(ebp+0x10) ": stmt length: too many inouts (1 required)\n") +22612 (flush *(ebp+0x10)) +22613 (stop *(ebp+0x14) 1) +22614 # never gets here +22615 +22616 $check-mu-length-stmt:error-too-few-outputs: +22617 (write-buffered *(ebp+0x10) "fn ") +22618 8b/-> *(ebp+0xc) 0/r32/eax +22619 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22620 (write-buffered *(ebp+0x10) %eax) +22621 (write-buffered *(ebp+0x10) ": stmt length: must have an output\n") +22622 (flush *(ebp+0x10)) +22623 (stop *(ebp+0x14) 1) +22624 # never gets here +22625 +22626 $check-mu-length-stmt:error-too-many-outputs: +22627 (write-buffered *(ebp+0x10) "fn ") +22628 8b/-> *(ebp+0xc) 0/r32/eax +22629 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22630 (write-buffered *(ebp+0x10) %eax) +22631 (write-buffered *(ebp+0x10) ": stmt length: too many outputs (1 required)\n") +22632 (flush *(ebp+0x10)) +22633 (stop *(ebp+0x14) 1) +22634 # never gets here +22635 +22636 $check-mu-length-stmt:error-output-not-in-register: +22637 (write-buffered *(ebp+0x10) "fn ") +22638 8b/-> *(ebp+0xc) 0/r32/eax +22639 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22640 (write-buffered *(ebp+0x10) %eax) +22641 (write-buffered *(ebp+0x10) ": stmt length: output '") +22642 (lookup *edi *(edi+4)) # Var-name Var-name => eax +22643 (write-buffered *(ebp+0x10) %eax) +22644 (write-buffered *(ebp+0x10) "' is not in a register\n") +22645 (flush *(ebp+0x10)) +22646 (stop *(ebp+0x14) 1) +22647 # never gets here +22648 +22649 $check-mu-length-stmt:error-invalid-output-type: +22650 (write-buffered *(ebp+0x10) "fn ") +22651 8b/-> *(ebp+0xc) 0/r32/eax +22652 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22653 (write-buffered *(ebp+0x10) %eax) +22654 (write-buffered *(ebp+0x10) ": stmt length: output '") +22655 (lookup *edi *(edi+4)) # Var-name Var-name => eax +22656 (write-buffered *(ebp+0x10) %eax) +22657 (write-buffered *(ebp+0x10) "' does not have the right type\n") +22658 (flush *(ebp+0x10)) +22659 (stop *(ebp+0x14) 1) +22660 # never gets here +22661 +22662 check-mu-compute-offset-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +22663 # . prologue +22664 55/push-ebp +22665 89/<- %ebp 4/r32/esp +22666 # . save registers +22667 50/push-eax +22668 51/push-ecx +22669 52/push-edx +22670 53/push-ebx +22671 56/push-esi +22672 57/push-edi +22673 # esi = stmt +22674 8b/-> *(ebp+8) 6/r32/esi +22675 # - check for 0 inouts +22676 # var base/ecx: (addr var) = stmt->inouts->value +22677 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22678 $check-mu-compute-offset-stmt:check-no-inouts: +22679 3d/compare-eax-and 0/imm32 +22680 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-too-few-inouts/disp32 +22681 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22682 89/<- %ecx 0/r32/eax +22683 # - check base type is either (addr array ...) in register or (array ...) on stack +22684 # var base-type/ebx: (addr type-tree) = lookup(base->type) +22685 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +22686 89/<- %ebx 0/r32/eax +22687 # if base-type is an atom, abort with a precise error +22688 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +22689 { +22690 74/jump-if-= break/disp8 +22691 (is-simple-mu-type? %ebx 3) # array => eax +22692 3d/compare-eax-and 0/imm32/false +22693 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-base-array-atom-type/disp32 +22694 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-base-non-array-type/disp32 +22695 } +22696 $check-mu-compute-offset-stmt:base-is-compound: +22697 # if type->left not addr or array, abort +22698 { +22699 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22700 (is-simple-mu-type? %eax 2) # addr => eax +22701 3d/compare-eax-and 0/imm32/false +22702 75/jump-if-!= break/disp8 +22703 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22704 (is-simple-mu-type? %eax 3) # array => eax +22705 3d/compare-eax-and 0/imm32/false +22706 75/jump-if-!= break/disp8 +22707 e9/jump $check-mu-compute-offset-stmt:error-base-non-array-type/disp32 +22708 } +22709 # if (type->left == addr) ensure type->right->left == array and type->register exists +22710 { +22711 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22712 (is-simple-mu-type? %eax 2) # addr => eax +22713 3d/compare-eax-and 0/imm32/false +22714 74/jump-if-= break/disp8 +22715 $check-mu-compute-offset-stmt:base-is-addr: +22716 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +22717 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +22718 (is-simple-mu-type? %eax 3) # array => eax +22719 3d/compare-eax-and 0/imm32/false +22720 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-base-non-array-type/disp32 +22721 } +22722 # if (base-type->left == addr) base-type = base-type->right +22723 { +22724 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +22725 (is-simple-mu-type? %eax 2) # addr => eax +22726 3d/compare-eax-and 0/imm32/false +22727 74/jump-if-= break/disp8 +22728 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +22729 89/<- %ebx 0/r32/eax +22730 } +22731 # - check for 1 inout +22732 # var index/ecx: (addr stmt-var) = stmt->inouts->next->value +22733 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22734 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22735 $check-mu-compute-offset-stmt:check-single-inout: +22736 3d/compare-eax-and 0/imm32 +22737 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-too-few-inouts/disp32 +22738 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22739 89/<- %ecx 0/r32/eax +22740 # - check index is either a literal or register +22741 # var index-type/edx: (addr type-tree) +22742 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +22743 89/<- %edx 0/r32/eax +22744 # index type must be a literal or int +22745 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom +22746 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-invalid-index-type/disp32 +22747 { +22748 $check-mu-compute-offset-stmt:index-type-is-atom: +22749 (is-simple-mu-type? %edx 0) # literal => eax +22750 3d/compare-eax-and 0/imm32/false +22751 75/jump-if-!= break/disp8 +22752 (is-simple-mu-type? %edx 1) # int => eax +22753 3d/compare-eax-and 0/imm32/false +22754 75/jump-if-!= break/disp8 +22755 e9/jump $check-mu-compute-offset-stmt:error-invalid-index-type/disp32 +22756 } +22757 # - check for too many inouts +22758 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22759 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22760 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22761 3d/compare-eax-and 0/imm32/false +22762 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-too-many-inouts/disp32 +22763 # - check for 0 outputs +22764 # var output/edi: (addr var) = stmt->outputs->value +22765 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +22766 3d/compare-eax-and 0/imm32/false +22767 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-too-few-outputs/disp32 +22768 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +22769 89/<- %edi 0/r32/eax +22770 # - check output type +22771 # must have a non-atomic type +22772 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +22773 89/<- %edx 0/r32/eax +22774 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom +22775 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-output-type-not-offset/disp32 +22776 # type must start with (offset ...) +22777 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +22778 (is-simple-mu-type? %eax 7) # offset => eax 22779 3d/compare-eax-and 0/imm32/false -22780 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-invalid-base-type/disp32 -22781 $check-mu-write-to-stream-stmt:check-base-is-addr-to-stream: -22782 # base-type = base-type->right -22783 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22784 89/<- %ebx 0/r32/eax -22785 # ensure base-type->left == stream -22786 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -22787 (is-simple-mu-type? %eax 0xb) # stream => eax -22788 3d/compare-eax-and 0/imm32/false -22789 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-invalid-base-type/disp32 -22790 # - check target type is (addr T) -22791 # var target/ecx: (addr stmt-var) = stmt->inouts->next->value -22792 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22793 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -22794 $check-mu-write-to-stream-stmt:check-single-inout: -22795 3d/compare-eax-and 0/imm32 -22796 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-too-few-inouts/disp32 -22797 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -22798 89/<- %ecx 0/r32/eax -22799 # var target-type/edx: (addr type-tree) -22800 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -22801 89/<- %edx 0/r32/eax -22802 # if target-type is an atom, it must be a literal or int -22803 $check-mu-write-to-stream-stmt:check-target-is-compound: -22804 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom -22805 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-target-type-not-address/disp32 -22806 $check-mu-write-to-stream-stmt:check-target-type: -22807 # target type must start with (addr ...) -22808 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -22809 (is-simple-mu-type? %eax 2) # addr => eax -22810 3d/compare-eax-and 0/imm32/false -22811 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-target-type-not-address/disp32 -22812 # if tail(base-type) != tail(target-type) abort -22813 (type-tail %ebx) # => eax -22814 89/<- %ebx 0/r32/eax -22815 (type-tail %edx) # => eax -22816 (type-equal? %ebx %eax) # => eax -22817 3d/compare-eax-and 0/imm32/false -22818 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-invalid-target-type/disp32 -22819 $check-mu-write-to-stream-stmt:check-too-many-inouts: -22820 # - check for too many inouts -22821 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22822 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -22823 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -22824 3d/compare-eax-and 0/imm32/false -22825 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-too-many-inouts/disp32 -22826 $check-mu-write-to-stream-stmt:check-unexpected-output: -22827 # - check for any output -22828 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -22829 3d/compare-eax-and 0/imm32/false -22830 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-unexpected-output/disp32 -22831 $check-mu-write-to-stream-stmt:end: -22832 # . restore registers -22833 5f/pop-to-edi -22834 5e/pop-to-esi -22835 5b/pop-to-ebx -22836 5a/pop-to-edx -22837 59/pop-to-ecx -22838 58/pop-to-eax -22839 # . epilogue -22840 89/<- %esp 5/r32/ebp -22841 5d/pop-to-ebp -22842 c3/return -22843 -22844 $check-mu-write-to-stream-stmt:error-invalid-base-type: -22845 (write-buffered *(ebp+0x10) "fn ") -22846 8b/-> *(ebp+0xc) 0/r32/eax -22847 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22848 (write-buffered *(ebp+0x10) %eax) -22849 (write-buffered *(ebp+0x10) ": stmt write-to-stream: var '") -22850 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -22851 (write-buffered *(ebp+0x10) %eax) -22852 (write-buffered *(ebp+0x10) "' must be an addr to a stream\n") -22853 (flush *(ebp+0x10)) -22854 (stop *(ebp+0x14) 1) -22855 # never gets here -22856 -22857 $check-mu-write-to-stream-stmt:error-too-few-inouts: -22858 (write-buffered *(ebp+0x10) "fn ") -22859 8b/-> *(ebp+0xc) 0/r32/eax -22860 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22861 (write-buffered *(ebp+0x10) %eax) -22862 (write-buffered *(ebp+0x10) ": stmt write-to-stream: too few inouts (2 required)\n") -22863 (flush *(ebp+0x10)) -22864 (stop *(ebp+0x14) 1) -22865 # never gets here -22866 -22867 $check-mu-write-to-stream-stmt:error-target-type-not-address: -22868 (write-buffered *(ebp+0x10) "fn ") -22869 8b/-> *(ebp+0xc) 0/r32/eax -22870 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22871 (write-buffered *(ebp+0x10) %eax) -22872 (write-buffered *(ebp+0x10) ": stmt write-to-stream: target '") -22873 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -22874 (write-buffered *(ebp+0x10) %eax) -22875 (write-buffered *(ebp+0x10) "' must be an addr\n") -22876 (flush *(ebp+0x10)) -22877 (stop *(ebp+0x14) 1) -22878 # never gets here -22879 -22880 $check-mu-write-to-stream-stmt:error-invalid-target-type: -22881 (write-buffered *(ebp+0x10) "fn ") -22882 8b/-> *(ebp+0xc) 0/r32/eax -22883 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22884 (write-buffered *(ebp+0x10) %eax) -22885 (write-buffered *(ebp+0x10) ": stmt write-to-stream: second inout '") -22886 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -22887 (write-buffered *(ebp+0x10) %eax) -22888 (write-buffered *(ebp+0x10) "' does not have the right type\n") -22889 (flush *(ebp+0x10)) -22890 (stop *(ebp+0x14) 1) -22891 # never gets here -22892 -22893 $check-mu-write-to-stream-stmt:error-too-many-inouts: -22894 (write-buffered *(ebp+0x10) "fn ") -22895 8b/-> *(ebp+0xc) 0/r32/eax -22896 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22897 (write-buffered *(ebp+0x10) %eax) -22898 (write-buffered *(ebp+0x10) ": stmt write-to-stream: too many inouts (2 required)\n") -22899 (flush *(ebp+0x10)) -22900 (stop *(ebp+0x14) 1) -22901 # never gets here -22902 -22903 $check-mu-write-to-stream-stmt:error-unexpected-output: -22904 (write-buffered *(ebp+0x10) "fn ") -22905 8b/-> *(ebp+0xc) 0/r32/eax -22906 (lookup *eax *(eax+4)) # Function-name Function-name => eax -22907 (write-buffered *(ebp+0x10) %eax) -22908 (write-buffered *(ebp+0x10) ": stmt write-to-stream: unexpected output\n") -22909 (flush *(ebp+0x10)) -22910 (stop *(ebp+0x14) 1) -22911 # never gets here -22912 -22913 check-mu-convert-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -22914 # . prologue -22915 55/push-ebp -22916 89/<- %ebp 4/r32/esp -22917 # . save registers -22918 $check-mu-convert-stmt:end: -22919 # . restore registers -22920 # . epilogue -22921 89/<- %esp 5/r32/ebp -22922 5d/pop-to-ebp -22923 c3/return -22924 -22925 check-mu-call: # stmt: (addr stmt), callee: (addr function), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -22926 # . prologue -22927 55/push-ebp -22928 89/<- %ebp 4/r32/esp -22929 # var type-parameters: (addr table (handle array byte) (addr type-tree) 8) -22930 68/push 0/imm32 -22931 # var type-parameters-storage: (table (handle array byte) (addr type-tree) 8) -22932 81 5/subop/subtract %esp 0x60/imm32 -22933 68/push 0x60/imm32/size -22934 68/push 0/imm32/read -22935 68/push 0/imm32/write -22936 # save a pointer to type-parameters-storage at type-parameters -22937 89/<- *(ebp-4) 4/r32/esp -22938 (clear-stream *(ebp-4)) -22939 # . save registers -22940 50/push-eax -22941 51/push-ecx -22942 52/push-edx -22943 53/push-ebx -22944 56/push-esi -22945 57/push-edi -22946 # esi = stmt -22947 8b/-> *(ebp+8) 6/r32/esi -22948 # edi = callee -22949 8b/-> *(ebp+0xc) 7/r32/edi -22950 # var inouts/ecx: (addr stmt-var) = lookup(stmt->inouts) -22951 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -22952 89/<- %ecx 0/r32/eax -22953 # var expected/edx: (addr list var) = lookup(f->inouts) -22954 (lookup *(edi+8) *(edi+0xc)) # Function-inouts Function-inouts => eax -22955 89/<- %edx 0/r32/eax -22956 { -22957 $check-mu-call:check-for-inouts: -22958 # if (inouts == 0) break -22959 81 7/subop/compare %ecx 0/imm32 -22960 0f 84/jump-if-= break/disp32 -22961 # if (expected == 0) error -22962 81 7/subop/compare %edx 0/imm32 -22963 0f 84/jump-if-= break/disp32 -22964 $check-mu-call:check-null-addr: -22965 # if (inouts->value->name == "0") continue -22966 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -22967 (lookup *eax *(eax+4)) # Var-name Var-name => eax -22968 (string-equal? %eax "0") # => eax -22969 3d/compare-eax-and 0/imm32/false -22970 0f 85/jump-if-!= $check-mu-call:continue-to-next-inout/disp32 -22971 $check-mu-call:check-inout-type: -22972 # var t/ebx: (addr type-tree) = inouts->value->type -22973 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -22974 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -22975 89/<- %ebx 0/r32/eax -22976 # if (inouts->is-deref?) t = t->right -22977 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -22978 { -22979 74/jump-if-= break/disp8 -22980 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -22981 89/<- %ebx 0/r32/eax -22982 # if t->right is null, t = t->left -22983 81 7/subop/compare *(ebx+0xc) 0/imm32 # Type-tree-right -22984 75/jump-if-!= break/disp8 -22985 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax -22986 89/<- %ebx 0/r32/eax -22987 } -22988 # var v2/eax: (addr v) = lookup(expected->value) -22989 (lookup *edx *(edx+4)) # List-value List-value => eax -22990 # var t2/eax: (addr type-tree) = lookup(v2->type) -22991 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -22992 # if (t != t2) error -22993 (type-match? %eax %ebx *(ebp-4)) # => eax -22994 3d/compare-eax-and 0/imm32/false -22995 { -22996 0f 85/jump-if-!= break/disp32 -22997 (write-buffered *(ebp+0x14) "fn ") -22998 8b/-> *(ebp+0x10) 0/r32/eax -22999 (lookup *eax *(eax+4)) # Function-name Function-name => eax -23000 (write-buffered *(ebp+0x14) %eax) -23001 (write-buffered *(ebp+0x14) ": call ") -23002 (lookup *edi *(edi+4)) # Function-name Function-name => eax -23003 (write-buffered *(ebp+0x14) %eax) -23004 (write-buffered *(ebp+0x14) ": type for inout '") -23005 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -23006 (lookup *eax *(eax+4)) # Var-name Var-name => eax -23007 (write-buffered *(ebp+0x14) %eax) -23008 (write-buffered *(ebp+0x14) "' is not right\n") -23009 (flush *(ebp+0x14)) -23010 (stop *(ebp+0x18) 1) -23011 } -23012 $check-mu-call:continue-to-next-inout: -23013 # inouts = lookup(inouts->next) -23014 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -23015 89/<- %ecx 0/r32/eax -23016 # expected = lookup(expected->next) -23017 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax -23018 89/<- %edx 0/r32/eax -23019 # -23020 e9/jump loop/disp32 -23021 } -23022 $check-mu-call:check-inout-count: -23023 # if (inouts == expected) proceed -23024 39/compare %ecx 2/r32/edx -23025 { -23026 0f 84/jump-if-= break/disp32 -23027 # exactly one of the two is null -23028 # if (inouts == 0) error("too many inouts") -23029 { -23030 81 7/subop/compare %ecx 0/imm32 -23031 0f 84/jump-if-= break/disp32 -23032 (write-buffered *(ebp+0x14) "fn ") -23033 8b/-> *(ebp+0x10) 0/r32/eax -23034 (lookup *eax *(eax+4)) # Function-name Function-name => eax -23035 (write-buffered *(ebp+0x14) %eax) -23036 (write-buffered *(ebp+0x14) ": call ") -23037 (lookup *edi *(edi+4)) # Function-name Function-name => eax -23038 (write-buffered *(ebp+0x14) %eax) -23039 (write-buffered *(ebp+0x14) ": too many inouts\n") -23040 (flush *(ebp+0x14)) -23041 (stop *(ebp+0x18) 1) -23042 } -23043 # if (expected == 0) error("too few inouts") -23044 { -23045 81 7/subop/compare %edx 0/imm32 -23046 0f 84/jump-if-= break/disp32 -23047 (write-buffered *(ebp+0x14) "fn ") -23048 8b/-> *(ebp+0x10) 0/r32/eax -23049 (lookup *eax *(eax+4)) # Function-name Function-name => eax -23050 (write-buffered *(ebp+0x14) %eax) -23051 (write-buffered *(ebp+0x14) ": call ") -23052 (lookup *edi *(edi+4)) # Function-name Function-name => eax -23053 (write-buffered *(ebp+0x14) %eax) -23054 (write-buffered *(ebp+0x14) ": too few inouts\n") -23055 (flush *(ebp+0x14)) -23056 (stop *(ebp+0x18) 1) -23057 } -23058 } -23059 $check-mu-call:check-outputs: -23060 # var outputs/ecx: (addr stmt-var) = lookup(stmt->outputs) -23061 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -23062 89/<- %ecx 0/r32/eax -23063 # var expected/edx: (addr list var) = lookup(f->outputs) -23064 (lookup *(edi+0x10) *(edi+0x14)) # Function-outputs Function-outputs => eax -23065 89/<- %edx 0/r32/eax -23066 { -23067 $check-mu-call:check-for-outputs: -23068 # if (outputs == 0) break -23069 81 7/subop/compare %ecx 0/imm32 -23070 0f 84/jump-if-= break/disp32 -23071 # if (expected == 0) error -23072 81 7/subop/compare %edx 0/imm32 -23073 0f 84/jump-if-= break/disp32 -23074 $check-mu-call:check-output-type: -23075 # var v/eax: (addr v) = lookup(outputs->value) -23076 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -23077 # var t/ebx: (addr type-tree) = lookup(v->type) -23078 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -23079 89/<- %ebx 0/r32/eax -23080 # if (outputs->is-deref?) t = t->right # TODO: check that t->left is an addr -23081 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -23082 { -23083 74/jump-if-= break/disp8 -23084 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -23085 89/<- %ebx 0/r32/eax -23086 } -23087 # var v2/eax: (addr v) = lookup(expected->value) -23088 (lookup *edx *(edx+4)) # List-value List-value => eax -23089 # var t2/eax: (addr type-tree) = lookup(v2->type) -23090 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -23091 # if (t != t2) error -23092 (type-match? %eax %ebx *(ebp-4)) # => eax -23093 3d/compare-eax-and 0/imm32/false -23094 { -23095 0f 85/jump-if-!= break/disp32 -23096 (write-buffered *(ebp+0x14) "fn ") -23097 8b/-> *(ebp+0x10) 0/r32/eax -23098 (lookup *eax *(eax+4)) # Function-name Function-name => eax -23099 (write-buffered *(ebp+0x14) %eax) -23100 (write-buffered *(ebp+0x14) ": call ") -23101 (lookup *edi *(edi+4)) # Function-name Function-name => eax -23102 (write-buffered *(ebp+0x14) %eax) -23103 (write-buffered *(ebp+0x14) ": type for output '") -23104 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -23105 (lookup *eax *(eax+4)) # Var-name Var-name => eax -23106 (write-buffered *(ebp+0x14) %eax) -23107 (write-buffered *(ebp+0x14) "' is not right\n") -23108 (flush *(ebp+0x14)) -23109 (stop *(ebp+0x18) 1) -23110 } -23111 $check-mu-call:check-output-register: -23112 # var v/eax: (addr v) = lookup(outputs->value) -23113 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -23114 # var r/ebx: (addr array byte) = lookup(v->register) -23115 (lookup *(eax+18) *(eax+0x1c)) # Var-register Var-register => eax -23116 89/<- %ebx 0/r32/eax -23117 # if (r == 0) error -23118 3d/compare-eax-and 0/imm32 -23119 { -23120 0f 85/jump-if-!= break/disp32 -23121 (write-buffered *(ebp+0x14) "fn ") -23122 8b/-> *(ebp+0x10) 0/r32/eax -23123 (lookup *eax *(eax+4)) # Function-name Function-name => eax -23124 (write-buffered *(ebp+0x14) %eax) -23125 (write-buffered *(ebp+0x14) ": call ") -23126 (lookup *edi *(edi+4)) # Function-name Function-name => eax -23127 (write-buffered *(ebp+0x14) %eax) -23128 (write-buffered *(ebp+0x14) ": output '") -23129 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -23130 (lookup *eax *(eax+4)) # Var-name Var-name => eax -23131 (write-buffered *(ebp+0x14) %eax) -23132 (write-buffered *(ebp+0x14) "' is not in a register\n") -23133 (flush *(ebp+0x14)) -23134 (stop *(ebp+0x18) 1) -23135 } -23136 # var v2/eax: (addr v) = lookup(expected->value) -23137 (lookup *edx *(edx+4)) # Stmt-var-value Stmt-var-value => eax -23138 # var r2/eax: (addr array byte) = lookup(v2->register) -23139 (lookup *(eax+18) *(eax+0x1c)) # Var-register Var-register => eax -23140 # if (r != r2) error -23141 (string-equal? %eax %ebx) # => eax -23142 3d/compare-eax-and 0/imm32/false -23143 { -23144 0f 85/jump-if-!= break/disp32 -23145 (write-buffered *(ebp+0x14) "fn ") -23146 8b/-> *(ebp+0x10) 0/r32/eax -23147 (lookup *eax *(eax+4)) # Function-name Function-name => eax -23148 (write-buffered *(ebp+0x14) %eax) -23149 (write-buffered *(ebp+0x14) ": call ") -23150 (lookup *edi *(edi+4)) # Function-name Function-name => eax -23151 (write-buffered *(ebp+0x14) %eax) -23152 (write-buffered *(ebp+0x14) ": register for output '") -23153 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -23154 (lookup *eax *(eax+4)) # Var-name Var-name => eax -23155 (write-buffered *(ebp+0x14) %eax) -23156 (write-buffered *(ebp+0x14) "' is not right\n") -23157 (flush *(ebp+0x14)) -23158 (stop *(ebp+0x18) 1) -23159 } -23160 $check-mu-call:continue-to-next-output: -23161 # outputs = lookup(outputs->next) -23162 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -23163 89/<- %ecx 0/r32/eax -23164 # expected = lookup(expected->next) -23165 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax -23166 89/<- %edx 0/r32/eax -23167 # -23168 e9/jump loop/disp32 -23169 } -23170 $check-mu-call:check-output-count: -23171 # if (outputs == expected) proceed -23172 39/compare %ecx 2/r32/edx -23173 { -23174 0f 84/jump-if-= break/disp32 -23175 # exactly one of the two is null -23176 # if (outputs == 0) error("too many outputs") -23177 { -23178 81 7/subop/compare %ecx 0/imm32 -23179 0f 84/jump-if-= break/disp32 -23180 (write-buffered *(ebp+0x14) "fn ") -23181 8b/-> *(ebp+0x10) 0/r32/eax -23182 (lookup *eax *(eax+4)) # Function-name Function-name => eax -23183 (write-buffered *(ebp+0x14) %eax) -23184 (write-buffered *(ebp+0x14) ": call ") -23185 (lookup *edi *(edi+4)) # Function-name Function-name => eax -23186 (write-buffered *(ebp+0x14) %eax) -23187 (write-buffered *(ebp+0x14) ": too many outputs\n") -23188 (flush *(ebp+0x14)) -23189 (stop *(ebp+0x18) 1) -23190 } -23191 # if (expected == 0) error("too few outputs") -23192 { -23193 81 7/subop/compare %edx 0/imm32 -23194 0f 84/jump-if-= break/disp32 -23195 (write-buffered *(ebp+0x14) "fn ") -23196 8b/-> *(ebp+0x10) 0/r32/eax -23197 (lookup *eax *(eax+4)) # Function-name Function-name => eax -23198 (write-buffered *(ebp+0x14) %eax) -23199 (write-buffered *(ebp+0x14) ": call ") -23200 (lookup *edi *(edi+4)) # Function-name Function-name => eax -23201 (write-buffered *(ebp+0x14) %eax) -23202 (write-buffered *(ebp+0x14) ": too few outputs\n") -23203 (flush *(ebp+0x14)) -23204 (stop *(ebp+0x18) 1) -23205 } -23206 } -23207 $check-mu-call:end: -23208 # . restore registers -23209 5f/pop-to-edi -23210 5e/pop-to-esi -23211 5b/pop-to-ebx -23212 5a/pop-to-edx -23213 59/pop-to-ecx -23214 58/pop-to-eax -23215 # . reclaim locals exclusively on the stack -23216 81 0/subop/add %esp 0x70/imm32 -23217 # . epilogue -23218 89/<- %esp 5/r32/ebp -23219 5d/pop-to-ebp -23220 c3/return -23221 -23222 # like type-equal? but takes literals type parameters into account -23223 type-match?: # def: (addr type-tree), call: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean -23224 # . prologue -23225 55/push-ebp -23226 89/<- %ebp 4/r32/esp -23227 # if (call is literal and def is numberlike) return true -23228 { -23229 $type-match?:check-literal-int: -23230 (is-simple-mu-type? *(ebp+0xc) 0) # literal => eax -23231 3d/compare-eax-and 0/imm32/false -23232 74/jump-if-= break/disp8 -23233 (is-mu-numberlike-output? *(ebp+8)) # => eax -23234 3d/compare-eax-and 0/imm32/false -23235 74/jump-if-= break/disp8 -23236 b8/copy-to-eax 1/imm32/true -23237 e9/jump $type-match?:end/disp32 -23238 } -23239 # if (call is literal-string and def is string) return true -23240 { -23241 $type-match?:check-literal-string: -23242 (is-simple-mu-type? *(ebp+0xc) 0x10) # literal-string => eax -23243 3d/compare-eax-and 0/imm32/false -23244 74/jump-if-= break/disp8 -23245 (is-mu-string-type? *(ebp+8)) # => eax -23246 3d/compare-eax-and 0/imm32/false -23247 74/jump-if-= break/disp8 -23248 b8/copy-to-eax 1/imm32/true -23249 e9/jump $type-match?:end/disp32 -23250 } -23251 $type-match?:baseline: -23252 # otherwise fall back -23253 (type-component-match? *(ebp+8) *(ebp+0xc) *(ebp+0x10)) # => eax -23254 $type-match?:end: -23255 # . epilogue -23256 89/<- %esp 5/r32/ebp -23257 5d/pop-to-ebp -23258 c3/return -23259 -23260 type-component-match?: # def: (addr type-tree), call: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean -23261 # . prologue -23262 55/push-ebp -23263 89/<- %ebp 4/r32/esp -23264 # . save registers -23265 51/push-ecx -23266 52/push-edx -23267 53/push-ebx -23268 # ecx = def -23269 8b/-> *(ebp+8) 1/r32/ecx -23270 # edx = call -23271 8b/-> *(ebp+0xc) 2/r32/edx -23272 $type-component-match?:compare-addr: -23273 # if (def == call) return true -23274 8b/-> %ecx 0/r32/eax # Var-type -23275 39/compare %edx 0/r32/eax # Var-type -23276 b8/copy-to-eax 1/imm32/true -23277 0f 84/jump-if-= $type-component-match?:end/disp32 -23278 # if (def == 0) return false -23279 b8/copy-to-eax 0/imm32/false -23280 81 7/subop/compare %ecx 0/imm32 # Type-tree-is-atom -23281 0f 84/jump-if-= $type-component-match?:end/disp32 -23282 # if (call == 0) return false -23283 81 7/subop/compare %edx 0/imm32 # Type-tree-is-atom -23284 0f 84/jump-if-= $type-component-match?:end/disp32 -23285 # if def is a type parameter, just check in type-parameters -23286 { -23287 $type-component-match?:check-type-parameter: -23288 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -23289 74/jump-if-= break/disp8 -23290 81 7/subop/compare *(ecx+4) 0xa/imm32/type-parameter # Type-tree-value -23291 75/jump-if-!= break/disp8 -23292 $type-component-match?:type-parameter: -23293 (type-parameter-match? *(ecx+8) *(ecx+0xc) %edx *(ebp+0x10)) # => eax -23294 e9/jump $type-component-match?:end/disp32 -23295 } -23296 # if def is a list containing just a type parameter, just check in type-parameters -23297 { -23298 $type-component-match?:check-list-type-parameter: -23299 # if def is a list.. -23300 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -23301 75/jump-if-!= break/disp8 -23302 # ..that's a singleton -23303 81 7/subop/compare *(ecx+0xc) 0/imm32 # Type-tree-left -23304 75/jump-if-!= break/disp8 -23305 # ..and whose head is a type parameter -23306 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23307 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -23308 74/jump-if-= break/disp8 -23309 81 7/subop/compare *(eax+4) 0xa/imm32/type-parameter # Type-tree-value -23310 75/jump-if-!= break/disp8 -23311 $type-component-match?:list-type-parameter: -23312 (type-parameter-match? *(eax+8) *(eax+0xc) %edx *(ebp+0x10)) # => eax -23313 e9/jump $type-component-match?:end/disp32 -23314 } -23315 $type-component-match?:compare-atom-state: -23316 # if (def->is-atom? != call->is-atom?) return false -23317 8b/-> *ecx 3/r32/ebx # Type-tree-is-atom -23318 39/compare *edx 3/r32/ebx # Type-tree-is-atom -23319 b8/copy-to-eax 0/imm32/false -23320 0f 85/jump-if-!= $type-component-match?:end/disp32 -23321 # if def->is-atom? return (def->value == call->value) -23322 { -23323 $type-component-match?:check-atom: -23324 81 7/subop/compare %ebx 0/imm32/false -23325 74/jump-if-= break/disp8 -23326 $type-component-match?:is-atom: -23327 8b/-> *(ecx+4) 0/r32/eax # Type-tree-value -23328 39/compare *(edx+4) 0/r32/eax # Type-tree-value -23329 0f 94/set-if-= %al -23330 81 4/subop/and %eax 0xff/imm32 -23331 e9/jump $type-component-match?:end/disp32 -23332 } -23333 $type-component-match?:check-left: -23334 # if (!type-component-match?(def->left, call->left)) return false -23335 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23336 89/<- %ebx 0/r32/eax -23337 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -23338 (type-component-match? %ebx %eax *(ebp+0x10)) # => eax -23339 3d/compare-eax-and 0/imm32/false -23340 74/jump-if-= $type-component-match?:end/disp8 -23341 $type-component-match?:check-right: -23342 # return type-component-match?(def->right, call->right) -23343 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -23344 89/<- %ebx 0/r32/eax -23345 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax -23346 (type-component-match? %ebx %eax *(ebp+0x10)) # => eax -23347 $type-component-match?:end: -23348 # . restore registers -23349 5b/pop-to-ebx -23350 5a/pop-to-edx -23351 59/pop-to-ecx -23352 # . epilogue -23353 89/<- %esp 5/r32/ebp -23354 5d/pop-to-ebp -23355 c3/return -23356 -23357 type-parameter-match?: # type-parameter-name: (handle array byte), type: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean -23358 # . prologue -23359 55/push-ebp -23360 89/<- %ebp 4/r32/esp -23361 # . save registers -23362 51/push-ecx -23363 # -23364 (get-or-insert-handle *(ebp+0x14) *(ebp+8) *(ebp+0xc) 0xc) # => eax -23365 # if parameter wasn't saved, save it -23366 { -23367 81 7/subop/compare *eax 0/imm32 -23368 75/jump-if-!= break/disp8 -23369 8b/-> *(ebp+0x10) 1/r32/ecx -23370 89/<- *eax 1/r32/ecx -23371 } -23372 # -23373 (type-equal? *(ebp+0x10) *eax) # => eax -23374 $type-parameter-match?:end: -23375 # . restore registers -23376 59/pop-to-ecx -23377 # . epilogue -23378 89/<- %esp 5/r32/ebp -23379 5d/pop-to-ebp -23380 c3/return +22780 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-output-type-not-offset/disp32 +22781 # if tail(base-type) != tail(output-type) abort +22782 (type-tail %ebx) # => eax +22783 89/<- %ebx 0/r32/eax +22784 (type-tail %edx) # => eax +22785 (type-equal? %ebx %eax) # => eax +22786 3d/compare-eax-and 0/imm32/false +22787 0f 84/jump-if-= $check-mu-compute-offset-stmt:error-bad-output-type/disp32 +22788 # - check for too many outputs +22789 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +22790 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +22791 3d/compare-eax-and 0/imm32/false +22792 0f 85/jump-if-!= $check-mu-compute-offset-stmt:error-too-many-outputs/disp32 +22793 $check-mu-compute-offset-stmt:end: +22794 # . restore registers +22795 5f/pop-to-edi +22796 5e/pop-to-esi +22797 5b/pop-to-ebx +22798 5a/pop-to-edx +22799 59/pop-to-ecx +22800 58/pop-to-eax +22801 # . epilogue +22802 89/<- %esp 5/r32/ebp +22803 5d/pop-to-ebp +22804 c3/return +22805 +22806 $check-mu-compute-offset-stmt:error-base-non-array-type: +22807 (write-buffered *(ebp+0x10) "fn ") +22808 8b/-> *(ebp+0xc) 0/r32/eax +22809 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22810 (write-buffered *(ebp+0x10) %eax) +22811 (write-buffered *(ebp+0x10) ": stmt compute-offset: var '") +22812 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22813 (write-buffered *(ebp+0x10) %eax) +22814 (write-buffered *(ebp+0x10) "' is not an array\n") +22815 (flush *(ebp+0x10)) +22816 (stop *(ebp+0x14) 1) +22817 # never gets here +22818 +22819 $check-mu-compute-offset-stmt:error-base-array-atom-type: +22820 (write-buffered *(ebp+0x10) "fn ") +22821 8b/-> *(ebp+0xc) 0/r32/eax +22822 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22823 (write-buffered *(ebp+0x10) %eax) +22824 (write-buffered *(ebp+0x10) ": stmt compute-offset: array '") +22825 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22826 (write-buffered *(ebp+0x10) %eax) +22827 (write-buffered *(ebp+0x10) "' must specify the type of its elements\n") +22828 (flush *(ebp+0x10)) +22829 (stop *(ebp+0x14) 1) +22830 # never gets here +22831 +22832 $check-mu-compute-offset-stmt:error-too-few-inouts: +22833 (write-buffered *(ebp+0x10) "fn ") +22834 8b/-> *(ebp+0xc) 0/r32/eax +22835 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22836 (write-buffered *(ebp+0x10) %eax) +22837 (write-buffered *(ebp+0x10) ": stmt compute-offset: too few inouts (2 required)\n") +22838 (flush *(ebp+0x10)) +22839 (stop *(ebp+0x14) 1) +22840 # never gets here +22841 +22842 $check-mu-compute-offset-stmt:error-invalid-index-type: +22843 (write-buffered *(ebp+0x10) "fn ") +22844 8b/-> *(ebp+0xc) 0/r32/eax +22845 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22846 (write-buffered *(ebp+0x10) %eax) +22847 (write-buffered *(ebp+0x10) ": stmt compute-offset: second argument '") +22848 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22849 (write-buffered *(ebp+0x10) %eax) +22850 (write-buffered *(ebp+0x10) "' must be an int\n") +22851 (flush *(ebp+0x10)) +22852 (stop *(ebp+0x14) 1) +22853 # never gets here +22854 +22855 $check-mu-compute-offset-stmt:error-index-offset-atom-type: +22856 (write-buffered *(ebp+0x10) "fn ") +22857 8b/-> *(ebp+0xc) 0/r32/eax +22858 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22859 (write-buffered *(ebp+0x10) %eax) +22860 (write-buffered *(ebp+0x10) ": stmt compute-offset: offset '") +22861 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22862 (write-buffered *(ebp+0x10) %eax) +22863 (write-buffered *(ebp+0x10) "' must specify the type of array elements\n") +22864 (flush *(ebp+0x10)) +22865 (stop *(ebp+0x14) 1) +22866 # never gets here +22867 +22868 $check-mu-compute-offset-stmt:error-index-on-stack: +22869 (write-buffered *(ebp+0x10) "fn ") +22870 8b/-> *(ebp+0xc) 0/r32/eax +22871 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22872 (write-buffered *(ebp+0x10) %eax) +22873 (write-buffered *(ebp+0x10) ": stmt compute-offset: second argument '") +22874 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +22875 (write-buffered *(ebp+0x10) %eax) +22876 (write-buffered *(ebp+0x10) "' must be in a register\n") +22877 (flush *(ebp+0x10)) +22878 (stop *(ebp+0x14) 1) +22879 # never gets here +22880 +22881 $check-mu-compute-offset-stmt:error-too-many-inouts: +22882 (write-buffered *(ebp+0x10) "fn ") +22883 8b/-> *(ebp+0xc) 0/r32/eax +22884 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22885 (write-buffered *(ebp+0x10) %eax) +22886 (write-buffered *(ebp+0x10) ": stmt compute-offset: too many inouts (2 required)\n") +22887 (flush *(ebp+0x10)) +22888 (stop *(ebp+0x14) 1) +22889 # never gets here +22890 +22891 $check-mu-compute-offset-stmt:error-too-few-outputs: +22892 (write-buffered *(ebp+0x10) "fn ") +22893 8b/-> *(ebp+0xc) 0/r32/eax +22894 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22895 (write-buffered *(ebp+0x10) %eax) +22896 (write-buffered *(ebp+0x10) ": stmt compute-offset: must have an output\n") +22897 (flush *(ebp+0x10)) +22898 (stop *(ebp+0x14) 1) +22899 # never gets here +22900 +22901 $check-mu-compute-offset-stmt:error-too-many-outputs: +22902 (write-buffered *(ebp+0x10) "fn ") +22903 8b/-> *(ebp+0xc) 0/r32/eax +22904 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22905 (write-buffered *(ebp+0x10) %eax) +22906 (write-buffered *(ebp+0x10) ": stmt compute-offset: too many outputs (1 required)\n") +22907 (flush *(ebp+0x10)) +22908 (stop *(ebp+0x14) 1) +22909 # never gets here +22910 +22911 $check-mu-compute-offset-stmt:error-output-not-in-register: +22912 (write-buffered *(ebp+0x10) "fn ") +22913 8b/-> *(ebp+0xc) 0/r32/eax +22914 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22915 (write-buffered *(ebp+0x10) %eax) +22916 (write-buffered *(ebp+0x10) ": stmt compute-offset: output '") +22917 (lookup *edi *(edi+4)) # Var-name Var-name => eax +22918 (write-buffered *(ebp+0x10) %eax) +22919 (write-buffered *(ebp+0x10) "' is not in a register\n") +22920 (flush *(ebp+0x10)) +22921 (stop *(ebp+0x14) 1) +22922 # never gets here +22923 +22924 $check-mu-compute-offset-stmt:error-output-type-not-offset: +22925 (write-buffered *(ebp+0x10) "fn ") +22926 8b/-> *(ebp+0xc) 0/r32/eax +22927 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22928 (write-buffered *(ebp+0x10) %eax) +22929 (write-buffered *(ebp+0x10) ": stmt compute-offset: output '") +22930 (lookup *edi *(edi+4)) # Var-name Var-name => eax +22931 (write-buffered *(ebp+0x10) %eax) +22932 (write-buffered *(ebp+0x10) "' must be an offset\n") +22933 (flush *(ebp+0x10)) +22934 (stop *(ebp+0x14) 1) +22935 # never gets here +22936 +22937 $check-mu-compute-offset-stmt:error-bad-output-type: +22938 (write-buffered *(ebp+0x10) "fn ") +22939 8b/-> *(ebp+0xc) 0/r32/eax +22940 (lookup *eax *(eax+4)) # Function-name Function-name => eax +22941 (write-buffered *(ebp+0x10) %eax) +22942 (write-buffered *(ebp+0x10) ": stmt compute-offset: output '") +22943 (lookup *edi *(edi+4)) # Var-name Var-name => eax +22944 (write-buffered *(ebp+0x10) %eax) +22945 (write-buffered *(ebp+0x10) "' does not have the right type\n") +22946 (flush *(ebp+0x10)) +22947 (stop *(ebp+0x14) 1) +22948 # never gets here +22949 +22950 check-mu-copy-object-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +22951 # . prologue +22952 55/push-ebp +22953 89/<- %ebp 4/r32/esp +22954 # . save registers +22955 50/push-eax +22956 51/push-ecx +22957 53/push-ebx +22958 56/push-esi +22959 57/push-edi +22960 # esi = stmt +22961 8b/-> *(ebp+8) 6/r32/esi +22962 $check-mu-copy-object-stmt:check-for-output: +22963 # if stmt->outputs abort +22964 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +22965 3d/compare-eax-and 0/imm32 +22966 0f 85/jump-if-!= $check-mu-copy-object-stmt:error-too-many-outputs/disp32 +22967 $check-mu-copy-object-stmt:get-left: +22968 # var dest/edi: (addr stmt-var) = stmt->inouts +22969 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +22970 89/<- %edi 0/r32/eax +22971 # zero inouts +22972 3d/compare-eax-and 0/imm32 +22973 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 +22974 $check-mu-copy-object-stmt:get-src: +22975 # var src/esi: (addr stmt-var) = dest->next +22976 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +22977 89/<- %esi 0/r32/eax +22978 # 1 inout +22979 3d/compare-eax-and 0/imm32 +22980 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 +22981 # > 2 inouts +22982 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +22983 3d/compare-eax-and 0/imm32 +22984 0f 85/jump-if-!= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 +22985 $check-mu-copy-object-stmt:types: +22986 # var src-type/ecx: (addr type-tree) = src->value->type +22987 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +22988 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +22989 89/<- %ecx 0/r32/eax +22990 # if (src->is-deref?) src-type = src-type->payload +22991 8b/-> *(esi+0x10) 0/r32/eax # Stmt-var-is-deref +22992 3d/compare-eax-and 0/imm32/false +22993 { +22994 74/jump-if-= break/disp8 +22995 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +22996 # if src-type->right is null, src-type = src-type->left +22997 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +22998 { +22999 75/jump-if-!= break/disp8 +23000 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +23001 } +23002 89/<- %ecx 0/r32/eax +23003 } +23004 # if src-type is not addr, abort +23005 (is-mu-addr-type? %ecx) # => eax +23006 3d/compare-eax-and 0/imm32/false +23007 0f 84/jump-if-= $check-mu-copy-object-stmt:error-invalid-types/disp32 +23008 # var dest-type/ebx: (addr type-tree) = dest->value->type +23009 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +23010 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +23011 89/<- %ebx 0/r32/eax +23012 # if (dest->is-deref?) dest-type = dest-type->payload +23013 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref +23014 3d/compare-eax-and 0/imm32/false +23015 { +23016 74/jump-if-= break/disp8 +23017 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23018 # if dest-type->right is null, dest-type = dest-type->left +23019 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +23020 { +23021 75/jump-if-!= break/disp8 +23022 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +23023 } +23024 89/<- %ebx 0/r32/eax +23025 } +23026 # if (dest-type != src-type) abort +23027 (type-equal? %ecx %ebx) # => eax +23028 3d/compare-eax-and 0/imm32 +23029 0f 84/jump-if-= $check-mu-copy-object-stmt:error-invalid-types/disp32 +23030 $check-mu-copy-object-stmt:end: +23031 # . restore registers +23032 5f/pop-to-edi +23033 5e/pop-to-esi +23034 5b/pop-to-ebx +23035 59/pop-to-ecx +23036 58/pop-to-eax +23037 # . epilogue +23038 89/<- %esp 5/r32/ebp +23039 5d/pop-to-ebp +23040 c3/return +23041 +23042 $check-mu-copy-object-stmt:error-incorrect-inouts: +23043 (write-buffered *(ebp+0x10) "fn ") +23044 8b/-> *(ebp+0xc) 0/r32/eax +23045 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23046 (write-buffered *(ebp+0x10) %eax) +23047 (write-buffered *(ebp+0x10) ": stmt 'copy-object' must have two inouts\n") +23048 (flush *(ebp+0x10)) +23049 (stop *(ebp+0x14) 1) +23050 # never gets here +23051 +23052 $check-mu-copy-object-stmt:error-too-many-outputs: +23053 (write-buffered *(ebp+0x10) "fn ") +23054 8b/-> *(ebp+0xc) 0/r32/eax +23055 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23056 (write-buffered *(ebp+0x10) %eax) +23057 (write-buffered *(ebp+0x10) ": stmt 'copy-object' must not have any outputs\n") +23058 (flush *(ebp+0x10)) +23059 (stop *(ebp+0x14) 1) +23060 # never gets here +23061 +23062 $check-mu-copy-object-stmt:error-invalid-types: +23063 (write-buffered *(ebp+0x10) "fn ") +23064 8b/-> *(ebp+0xc) 0/r32/eax +23065 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23066 (write-buffered *(ebp+0x10) %eax) +23067 (write-buffered *(ebp+0x10) ": stmt copy-object: two inouts with identical addr types expected\n") +23068 (flush *(ebp+0x10)) +23069 (stop *(ebp+0x14) 1) +23070 # never gets here +23071 +23072 check-mu-clear-object-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +23073 # . prologue +23074 55/push-ebp +23075 89/<- %ebp 4/r32/esp +23076 # . save registers +23077 50/push-eax +23078 51/push-ecx +23079 53/push-ebx +23080 56/push-esi +23081 57/push-edi +23082 # esi = stmt +23083 8b/-> *(ebp+8) 6/r32/esi +23084 $check-mu-clear-object-stmt:check-for-output: +23085 # if stmt->outputs abort +23086 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +23087 3d/compare-eax-and 0/imm32 +23088 0f 85/jump-if-!= $check-mu-clear-object-stmt:error-too-many-outputs/disp32 +23089 $check-mu-clear-object-stmt:get-left: +23090 # var dest/edi: (addr stmt-var) = stmt->inouts +23091 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23092 89/<- %edi 0/r32/eax +23093 # zero inouts +23094 3d/compare-eax-and 0/imm32 +23095 0f 84/jump-if-= $check-mu-clear-object-stmt:error-incorrect-inouts/disp32 +23096 $check-mu-clear-object-stmt:get-src: +23097 # > 1 inout +23098 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +23099 3d/compare-eax-and 0/imm32 +23100 0f 85/jump-if-!= $check-mu-clear-object-stmt:error-incorrect-inouts/disp32 +23101 $check-mu-clear-object-stmt:types: +23102 # var src-type/ecx: (addr type-tree) = src->value->type +23103 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +23104 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +23105 89/<- %ecx 0/r32/eax +23106 # if (src->is-deref?) src-type = src-type->payload +23107 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref +23108 3d/compare-eax-and 0/imm32/false +23109 { +23110 74/jump-if-= break/disp8 +23111 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +23112 # if src-type->right is null, src-type = src-type->left +23113 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +23114 { +23115 75/jump-if-!= break/disp8 +23116 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +23117 } +23118 89/<- %ecx 0/r32/eax +23119 } +23120 # if src-type is not addr, abort +23121 (is-mu-addr-type? %ecx) # => eax +23122 3d/compare-eax-and 0/imm32/false +23123 0f 84/jump-if-= $check-mu-clear-object-stmt:error-invalid-type/disp32 +23124 $check-mu-clear-object-stmt:end: +23125 # . restore registers +23126 5f/pop-to-edi +23127 5e/pop-to-esi +23128 5b/pop-to-ebx +23129 59/pop-to-ecx +23130 58/pop-to-eax +23131 # . epilogue +23132 89/<- %esp 5/r32/ebp +23133 5d/pop-to-ebp +23134 c3/return +23135 +23136 $check-mu-clear-object-stmt:error-incorrect-inouts: +23137 (write-buffered *(ebp+0x10) "fn ") +23138 8b/-> *(ebp+0xc) 0/r32/eax +23139 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23140 (write-buffered *(ebp+0x10) %eax) +23141 (write-buffered *(ebp+0x10) ": stmt 'clear-object' must have a single inout\n") +23142 (flush *(ebp+0x10)) +23143 (stop *(ebp+0x14) 1) +23144 # never gets here +23145 +23146 $check-mu-clear-object-stmt:error-too-many-outputs: +23147 (write-buffered *(ebp+0x10) "fn ") +23148 8b/-> *(ebp+0xc) 0/r32/eax +23149 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23150 (write-buffered *(ebp+0x10) %eax) +23151 (write-buffered *(ebp+0x10) ": stmt 'clear-object' must not have any outputs\n") +23152 (flush *(ebp+0x10)) +23153 (stop *(ebp+0x14) 1) +23154 # never gets here +23155 +23156 $check-mu-clear-object-stmt:error-invalid-type: +23157 (write-buffered *(ebp+0x10) "fn ") +23158 8b/-> *(ebp+0xc) 0/r32/eax +23159 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23160 (write-buffered *(ebp+0x10) %eax) +23161 (write-buffered *(ebp+0x10) ": stmt clear-object: inout must have an addr type\n") +23162 (flush *(ebp+0x10)) +23163 (stop *(ebp+0x14) 1) +23164 # never gets here +23165 +23166 check-mu-allocate-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +23167 # . prologue +23168 55/push-ebp +23169 89/<- %ebp 4/r32/esp +23170 # . save registers +23171 50/push-eax +23172 53/push-ebx +23173 56/push-esi +23174 57/push-edi +23175 # esi = stmt +23176 8b/-> *(ebp+8) 6/r32/esi +23177 $check-mu-allocate-stmt:check-for-output: +23178 # if stmt->outputs abort +23179 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +23180 3d/compare-eax-and 0/imm32 +23181 0f 85/jump-if-!= $check-mu-allocate-stmt:error-too-many-outputs/disp32 +23182 $check-mu-allocate-stmt:get-target: +23183 # var target/edi: (addr stmt-var) = stmt->inouts +23184 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23185 89/<- %edi 0/r32/eax +23186 # zero inouts +23187 3d/compare-eax-and 0/imm32 +23188 0f 84/jump-if-= $check-mu-allocate-stmt:error-incorrect-inouts/disp32 +23189 # > 1 inouts +23190 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +23191 3d/compare-eax-and 0/imm32 +23192 0f 85/jump-if-!= $check-mu-allocate-stmt:error-incorrect-inouts/disp32 +23193 $check-mu-allocate-stmt:check-type: +23194 # var target-type/ebx: (addr type-tree) = target->value->type +23195 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +23196 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +23197 89/<- %ebx 0/r32/eax +23198 # if (target->is-deref?) target-type = target-type->payload +23199 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref +23200 3d/compare-eax-and 0/imm32/false +23201 { +23202 74/jump-if-= break/disp8 +23203 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23204 # if target-type->right is null, target-type = target-type->left +23205 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +23206 { +23207 75/jump-if-!= break/disp8 +23208 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +23209 } +23210 89/<- %ebx 0/r32/eax +23211 } +23212 # if target-type is not addr, abort +23213 (is-mu-addr-type? %ebx) # => eax +23214 3d/compare-eax-and 0/imm32/false +23215 0f 84/jump-if-= $check-mu-allocate-stmt:error-invalid-type/disp32 +23216 # if target-type->right is an atom, abort +23217 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23218 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +23219 0f 85/jump-if-!= $check-mu-allocate-stmt:error-invalid-type/disp32 +23220 # if target-type->right->left is not handle, abort +23221 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +23222 (is-simple-mu-type? %eax 4) # handle => eax +23223 3d/compare-eax-and 0/imm32/false +23224 0f 84/jump-if-= $check-mu-allocate-stmt:error-invalid-type/disp32 +23225 $check-mu-allocate-stmt:end: +23226 # . restore registers +23227 5f/pop-to-edi +23228 5e/pop-to-esi +23229 5b/pop-to-ebx +23230 58/pop-to-eax +23231 # . epilogue +23232 89/<- %esp 5/r32/ebp +23233 5d/pop-to-ebp +23234 c3/return +23235 +23236 $check-mu-allocate-stmt:error-incorrect-inouts: +23237 (write-buffered *(ebp+0x10) "fn ") +23238 8b/-> *(ebp+0xc) 0/r32/eax +23239 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23240 (write-buffered *(ebp+0x10) %eax) +23241 (write-buffered *(ebp+0x10) ": stmt 'allocate' must have a single inout\n") +23242 (flush *(ebp+0x10)) +23243 (stop *(ebp+0x14) 1) +23244 # never gets here +23245 +23246 $check-mu-allocate-stmt:error-too-many-outputs: +23247 (write-buffered *(ebp+0x10) "fn ") +23248 8b/-> *(ebp+0xc) 0/r32/eax +23249 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23250 (write-buffered *(ebp+0x10) %eax) +23251 (write-buffered *(ebp+0x10) ": stmt 'allocate' must not have any outputs\n") +23252 (flush *(ebp+0x10)) +23253 (stop *(ebp+0x14) 1) +23254 # never gets here +23255 +23256 $check-mu-allocate-stmt:error-invalid-type: +23257 (write-buffered *(ebp+0x10) "fn ") +23258 8b/-> *(ebp+0xc) 0/r32/eax +23259 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23260 (write-buffered *(ebp+0x10) %eax) +23261 (write-buffered *(ebp+0x10) ": stmt allocate: inout '") +23262 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +23263 (lookup *eax *(eax+4)) # Var-name Var-name => eax +23264 (write-buffered *(ebp+0x10) %eax) +23265 (write-buffered *(ebp+0x10) "' must have type (addr handle ...)\n") +23266 (flush *(ebp+0x10)) +23267 (stop *(ebp+0x14) 1) +23268 # never gets here +23269 +23270 check-mu-populate-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +23271 # . prologue +23272 55/push-ebp +23273 89/<- %ebp 4/r32/esp +23274 # . save registers +23275 50/push-eax +23276 53/push-ebx +23277 56/push-esi +23278 57/push-edi +23279 # esi = stmt +23280 8b/-> *(ebp+8) 6/r32/esi +23281 $check-mu-populate-stmt:check-for-output: +23282 # if stmt->outputs abort +23283 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +23284 3d/compare-eax-and 0/imm32 +23285 0f 85/jump-if-!= $check-mu-populate-stmt:error-too-many-outputs/disp32 +23286 $check-mu-populate-stmt:get-target: +23287 # var target/edi: (addr stmt-var) = stmt->inouts +23288 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23289 89/<- %edi 0/r32/eax +23290 # zero inouts +23291 3d/compare-eax-and 0/imm32 +23292 0f 84/jump-if-= $check-mu-populate-stmt:error-incorrect-inouts/disp32 +23293 $check-mu-populate-stmt:get-length: +23294 # var length/esi: (addr stmt-var) = dest->next +23295 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +23296 89/<- %esi 0/r32/eax +23297 # 1 inout +23298 3d/compare-eax-and 0/imm32 +23299 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 +23300 # > 2 inouts +23301 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +23302 3d/compare-eax-and 0/imm32 +23303 0f 85/jump-if-!= $check-mu-populate-stmt:error-incorrect-inouts/disp32 +23304 $check-mu-populate-stmt:check-target-type: +23305 # var target-type/ebx: (addr type-tree) = target->value->type +23306 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +23307 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +23308 89/<- %ebx 0/r32/eax +23309 $check-mu-populate-stmt:check-target-type-deref: +23310 # if (target->is-deref?) target-type = target-type->payload +23311 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref +23312 3d/compare-eax-and 0/imm32/false +23313 { +23314 74/jump-if-= break/disp8 +23315 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23316 # if target-type->right is null, target-type = target-type->left +23317 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +23318 { +23319 75/jump-if-!= break/disp8 +23320 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +23321 } +23322 89/<- %ebx 0/r32/eax +23323 } +23324 $check-mu-populate-stmt:check-target-type-addr: +23325 # if target-type is not addr, abort +23326 (is-mu-addr-type? %ebx) # => eax +23327 3d/compare-eax-and 0/imm32/false +23328 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-target-type/disp32 +23329 # if target-type->right is an atom, abort +23330 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23331 89/<- %ebx 0/r32/eax +23332 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +23333 0f 85/jump-if-!= $check-mu-populate-stmt:error-invalid-target-type/disp32 +23334 $check-mu-populate-stmt:check-target-type-handle: +23335 # if target-type->right->left is not handle, abort +23336 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +23337 (is-simple-mu-type? %eax 4) # handle => eax +23338 3d/compare-eax-and 0/imm32/false +23339 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-target-type/disp32 +23340 # if target-type->right->right is an atom, abort +23341 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23342 89/<- %ebx 0/r32/eax +23343 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +23344 0f 85/jump-if-!= $check-mu-populate-stmt:error-invalid-target-type/disp32 +23345 $check-mu-populate-stmt:check-target-type-array: +23346 # if target-type->right->right->left is not array, abort +23347 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +23348 (is-simple-mu-type? %eax 3) # array => eax +23349 3d/compare-eax-and 0/imm32/false +23350 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-target-type/disp32 +23351 $check-mu-populate-stmt:check-length-type: +23352 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +23353 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +23354 89/<- %ebx 0/r32/eax +23355 (is-simple-mu-type? %ebx 0) # literal => eax +23356 3d/compare-eax-and 0/imm32/false +23357 75/jump-if-!= $check-mu-populate-stmt:end/disp8 +23358 (is-simple-mu-type? %ebx 1) # int => eax +23359 3d/compare-eax-and 0/imm32/false +23360 0f 84/jump-if-= $check-mu-populate-stmt:error-invalid-length-type/disp32 +23361 $check-mu-populate-stmt:end: +23362 # . restore registers +23363 5f/pop-to-edi +23364 5e/pop-to-esi +23365 5b/pop-to-ebx +23366 58/pop-to-eax +23367 # . epilogue +23368 89/<- %esp 5/r32/ebp +23369 5d/pop-to-ebp +23370 c3/return +23371 +23372 $check-mu-populate-stmt:error-incorrect-inouts: +23373 (write-buffered *(ebp+0x10) "fn ") +23374 8b/-> *(ebp+0xc) 0/r32/eax +23375 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23376 (write-buffered *(ebp+0x10) %eax) +23377 (write-buffered *(ebp+0x10) ": stmt 'populate' must have two inouts\n") +23378 (flush *(ebp+0x10)) +23379 (stop *(ebp+0x14) 1) +23380 # never gets here 23381 -23382 size-of: # v: (addr var) -> result/eax: int -23383 # . prologue -23384 55/push-ebp -23385 89/<- %ebp 4/r32/esp -23386 # . save registers -23387 51/push-ecx -23388 # var t/ecx: (addr type-tree) = lookup(v->type) -23389 8b/-> *(ebp+8) 1/r32/ecx -23390 #? (write-buffered Stderr "size-of ") -23391 #? (write-int32-hex-buffered Stderr %ecx) -23392 #? (write-buffered Stderr Newline) -23393 #? (write-buffered Stderr "type allocid: ") -23394 #? (write-int32-hex-buffered Stderr *(ecx+8)) -23395 #? (write-buffered Stderr Newline) -23396 #? (flush Stderr) -23397 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -23398 89/<- %ecx 0/r32/eax -23399 # if is-mu-array?(t) return size-of-array(t) -23400 { -23401 (is-mu-array? %ecx) # => eax -23402 3d/compare-eax-and 0/imm32/false -23403 74/jump-if-= break/disp8 -23404 (size-of-array %ecx) # => eax -23405 eb/jump $size-of:end/disp8 -23406 } -23407 # if is-mu-stream?(t) return size-of-stream(t) -23408 { -23409 (is-mu-stream? %ecx) # => eax -23410 3d/compare-eax-and 0/imm32/false -23411 74/jump-if-= break/disp8 -23412 (size-of-stream %ecx) # => eax -23413 eb/jump $size-of:end/disp8 -23414 } -23415 # if (!t->is-atom?) t = lookup(t->left) -23416 { -23417 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -23418 75/jump-if-!= break/disp8 -23419 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23420 89/<- %ecx 0/r32/eax -23421 } -23422 # TODO: assert t->is-atom? -23423 (size-of-type-id *(ecx+4)) # Type-tree-value => eax -23424 $size-of:end: -23425 # . restore registers -23426 59/pop-to-ecx -23427 # . epilogue -23428 89/<- %esp 5/r32/ebp -23429 5d/pop-to-ebp -23430 c3/return -23431 -23432 size-of-deref: # v: (addr var) -> result/eax: int -23433 # . prologue -23434 55/push-ebp -23435 89/<- %ebp 4/r32/esp -23436 # . save registers -23437 51/push-ecx -23438 # var t/ecx: (addr type-tree) = lookup(v->type) -23439 8b/-> *(ebp+8) 1/r32/ecx -23440 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -23441 89/<- %ecx 0/r32/eax -23442 # TODO: assert(t is an addr) -23443 # t = lookup(t->right) -23444 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -23445 89/<- %ecx 0/r32/eax -23446 # if is-mu-array?(t) return size-of-array(t) -23447 { -23448 (is-mu-array? %ecx) # => eax -23449 3d/compare-eax-and 0/imm32/false -23450 74/jump-if-= break/disp8 -23451 (size-of-array %ecx) # => eax -23452 eb/jump $size-of-deref:end/disp8 -23453 } -23454 # if is-mu-stream?(t) return size-of-stream(t) -23455 { -23456 (is-mu-stream? %ecx) # => eax -23457 3d/compare-eax-and 0/imm32/false -23458 74/jump-if-= break/disp8 -23459 (size-of-stream %ecx) # => eax -23460 eb/jump $size-of-deref:end/disp8 -23461 } -23462 # if (!t->is-atom?) t = lookup(t->left) +23382 $check-mu-populate-stmt:error-too-many-outputs: +23383 (write-buffered *(ebp+0x10) "fn ") +23384 8b/-> *(ebp+0xc) 0/r32/eax +23385 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23386 (write-buffered *(ebp+0x10) %eax) +23387 (write-buffered *(ebp+0x10) ": stmt 'populate' must not have any outputs\n") +23388 (flush *(ebp+0x10)) +23389 (stop *(ebp+0x14) 1) +23390 # never gets here +23391 +23392 $check-mu-populate-stmt:error-invalid-target-type: +23393 (write-buffered *(ebp+0x10) "fn ") +23394 8b/-> *(ebp+0xc) 0/r32/eax +23395 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23396 (write-buffered *(ebp+0x10) %eax) +23397 (write-buffered *(ebp+0x10) ": stmt populate: first inout '") +23398 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +23399 (lookup *eax *(eax+4)) # Var-name Var-name => eax +23400 (write-buffered *(ebp+0x10) %eax) +23401 (write-buffered *(ebp+0x10) "' must have type (addr handle array ...)\n") +23402 (flush *(ebp+0x10)) +23403 (stop *(ebp+0x14) 1) +23404 # never gets here +23405 +23406 $check-mu-populate-stmt:error-invalid-length-type: +23407 (write-buffered *(ebp+0x10) "fn ") +23408 8b/-> *(ebp+0xc) 0/r32/eax +23409 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23410 (write-buffered *(ebp+0x10) %eax) +23411 (write-buffered *(ebp+0x10) ": stmt populate: second inout '") +23412 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +23413 (lookup *eax *(eax+4)) # Var-name Var-name => eax +23414 (write-buffered *(ebp+0x10) %eax) +23415 (write-buffered *(ebp+0x10) "' must be an int\n") +23416 (flush *(ebp+0x10)) +23417 (stop *(ebp+0x14) 1) +23418 # never gets here +23419 +23420 check-mu-populate-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +23421 # . prologue +23422 55/push-ebp +23423 89/<- %ebp 4/r32/esp +23424 # . save registers +23425 50/push-eax +23426 53/push-ebx +23427 56/push-esi +23428 57/push-edi +23429 # esi = stmt +23430 8b/-> *(ebp+8) 6/r32/esi +23431 $check-mu-populate-stream-stmt:check-for-output: +23432 # if stmt->outputs abort +23433 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +23434 3d/compare-eax-and 0/imm32 +23435 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-too-many-outputs/disp32 +23436 $check-mu-populate-stream-stmt:get-target: +23437 # var target/edi: (addr stmt-var) = stmt->inouts +23438 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23439 89/<- %edi 0/r32/eax +23440 # zero inouts +23441 3d/compare-eax-and 0/imm32 +23442 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-incorrect-inouts/disp32 +23443 $check-mu-populate-stream-stmt:get-length: +23444 # var length/esi: (addr stmt-var) = dest->next +23445 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +23446 89/<- %esi 0/r32/eax +23447 # 1 inout +23448 3d/compare-eax-and 0/imm32 +23449 0f 84/jump-if-= $check-mu-copy-object-stmt:error-incorrect-inouts/disp32 +23450 # > 2 inouts +23451 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +23452 3d/compare-eax-and 0/imm32 +23453 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-incorrect-inouts/disp32 +23454 $check-mu-populate-stream-stmt:check-target-type: +23455 # var target-type/ebx: (addr type-tree) = target->value->type +23456 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +23457 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +23458 89/<- %ebx 0/r32/eax +23459 $check-mu-populate-stream-stmt:check-target-type-deref: +23460 # if (target->is-deref?) target-type = target-type->payload +23461 8b/-> *(edi+0x10) 0/r32/eax # Stmt-var-is-deref +23462 3d/compare-eax-and 0/imm32/false 23463 { -23464 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -23465 75/jump-if-!= break/disp8 -23466 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23467 89/<- %ecx 0/r32/eax -23468 } -23469 # TODO: assert t->is-atom? -23470 (size-of-type-id *(ecx+4)) # Type-tree-value => eax -23471 $size-of-deref:end: -23472 # . restore registers -23473 59/pop-to-ecx -23474 # . epilogue -23475 89/<- %esp 5/r32/ebp -23476 5d/pop-to-ebp -23477 c3/return -23478 -23479 is-mu-array?: # t: (addr type-tree) -> result/eax: boolean -23480 # . prologue -23481 55/push-ebp -23482 89/<- %ebp 4/r32/esp -23483 # . save registers -23484 51/push-ecx -23485 # ecx = t -23486 8b/-> *(ebp+8) 1/r32/ecx -23487 # if t->is-atom?, return false -23488 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -23489 75/jump-if-!= $is-mu-array?:return-false/disp8 -23490 # if !t->left->is-atom?, return false -23491 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23492 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -23493 74/jump-if-= $is-mu-array?:return-false/disp8 -23494 # return t->left->value == array -23495 81 7/subop/compare *(eax+4) 3/imm32/array-type-id # Type-tree-value -23496 0f 94/set-if-= %al -23497 81 4/subop/and %eax 0xff/imm32 -23498 eb/jump $is-mu-array?:end/disp8 -23499 $is-mu-array?:return-false: -23500 b8/copy-to-eax 0/imm32/false -23501 $is-mu-array?:end: -23502 # . restore registers -23503 59/pop-to-ecx -23504 # . epilogue -23505 89/<- %esp 5/r32/ebp -23506 5d/pop-to-ebp -23507 c3/return -23508 -23509 # size of a statically allocated array where the size is part of the type expression -23510 size-of-array: # a: (addr type-tree) -> result/eax: int -23511 # . prologue -23512 55/push-ebp -23513 89/<- %ebp 4/r32/esp -23514 # . save registers -23515 51/push-ecx -23516 52/push-edx -23517 # -23518 8b/-> *(ebp+8) 1/r32/ecx -23519 # TODO: assert that a->left is 'array' -23520 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -23521 89/<- %ecx 0/r32/eax -23522 # var elem-type/edx: type-id = a->right->left->value -23523 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23524 8b/-> *(eax+4) 2/r32/edx # Type-tree-value -23525 # TODO: assert that a->right->right->left->value == size -23526 # var array-size/ecx: int = a->right->right->left->value-size -23527 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -23528 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -23529 8b/-> *(eax+8) 1/r32/ecx # Type-tree-value-size -23530 # return 4 + array-size * size-of(elem-type) -23531 (size-of-type-id-as-array-element %edx) # => eax -23532 f7 4/subop/multiply-into-edx-eax %ecx -23533 05/add-to-eax 4/imm32 # for array size -23534 # TODO: check edx for overflow -23535 $size-of-array:end: -23536 # . restore registers -23537 5a/pop-to-edx -23538 59/pop-to-ecx -23539 # . epilogue -23540 89/<- %esp 5/r32/ebp -23541 5d/pop-to-ebp -23542 c3/return -23543 -23544 is-mu-stream?: # t: (addr type-tree) -> result/eax: boolean -23545 # . prologue -23546 55/push-ebp -23547 89/<- %ebp 4/r32/esp -23548 # . save registers -23549 51/push-ecx -23550 # ecx = t -23551 8b/-> *(ebp+8) 1/r32/ecx -23552 # if t->is-atom?, return false -23553 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -23554 75/jump-if-!= $is-mu-stream?:return-false/disp8 -23555 # if !t->left->is-atom?, return false -23556 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23557 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -23558 74/jump-if-= $is-mu-stream?:return-false/disp8 -23559 # return t->left->value == stream -23560 81 7/subop/compare *(eax+4) 0xb/imm32/stream-type-id # Type-tree-value -23561 0f 94/set-if-= %al -23562 81 4/subop/and %eax 0xff/imm32 -23563 eb/jump $is-mu-stream?:end/disp8 -23564 $is-mu-stream?:return-false: -23565 b8/copy-to-eax 0/imm32/false -23566 $is-mu-stream?:end: -23567 # . restore registers -23568 59/pop-to-ecx -23569 # . epilogue -23570 89/<- %esp 5/r32/ebp -23571 5d/pop-to-ebp -23572 c3/return -23573 -23574 # size of a statically allocated stream where the size is part of the type expression -23575 size-of-stream: # a: (addr type-tree) -> result/eax: int -23576 # . prologue -23577 55/push-ebp -23578 89/<- %ebp 4/r32/esp -23579 # -23580 (size-of-array *(ebp+8)) # assumes we ignore the actual type name 'array' in the type -23581 05/add-to-eax 8/imm32 # for read/write pointers -23582 $size-of-stream:end: -23583 # . epilogue -23584 89/<- %esp 5/r32/ebp -23585 5d/pop-to-ebp -23586 c3/return -23587 -23588 size-of-type-id: # t: type-id -> result/eax: int -23589 # . prologue -23590 55/push-ebp -23591 89/<- %ebp 4/r32/esp -23592 # . save registers -23593 51/push-ecx -23594 # var out/ecx: (handle typeinfo) -23595 68/push 0/imm32 -23596 68/push 0/imm32 -23597 89/<- %ecx 4/r32/esp -23598 # eax = t -23599 8b/-> *(ebp+8) 0/r32/eax -23600 # if t is a literal, return 0 -23601 3d/compare-eax-and 0/imm32 -23602 0f 84/jump-if-= $size-of-type-id:end/disp32 # eax changes type from type-id to int -23603 # if t is a byte, return 4 (because we don't really support non-multiples of 4) -23604 3d/compare-eax-and 8/imm32/byte -23605 { -23606 75/jump-if-!= break/disp8 -23607 b8/copy-to-eax 4/imm32 -23608 eb/jump $size-of-type-id:end/disp8 -23609 } -23610 # if t is a handle, return 8 -23611 3d/compare-eax-and 4/imm32/handle -23612 { -23613 75/jump-if-!= break/disp8 -23614 b8/copy-to-eax 8/imm32 -23615 eb/jump $size-of-type-id:end/disp8 # eax changes type from type-id to int -23616 } -23617 # if t is a slice, return 8 -23618 3d/compare-eax-and 0xc/imm32/slice -23619 { -23620 75/jump-if-!= break/disp8 -23621 b8/copy-to-eax 8/imm32 -23622 eb/jump $size-of-type-id:end/disp8 # eax changes type from type-id to int -23623 } -23624 # if t is a user-defined type, return its size -23625 # TODO: support non-atom type -23626 (find-typeinfo %eax %ecx) -23627 { -23628 81 7/subop/compare *ecx 0/imm32 -23629 74/jump-if-= break/disp8 -23630 $size-of-type-id:user-defined: -23631 (lookup *ecx *(ecx+4)) # => eax -23632 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes -23633 eb/jump $size-of-type-id:end/disp8 -23634 } -23635 # otherwise return the word size -23636 b8/copy-to-eax 4/imm32 -23637 $size-of-type-id:end: -23638 # . reclaim locals -23639 81 0/subop/add %esp 8/imm32 -23640 # . restore registers -23641 59/pop-to-ecx -23642 # . epilogue -23643 89/<- %esp 5/r32/ebp -23644 5d/pop-to-ebp -23645 c3/return -23646 -23647 # Minor violation of our type system since it returns an addr. But we could -23648 # replace it with a handle some time. -23649 # Returns null if t is an atom. -23650 type-tail: # t: (addr type-tree) -> out/eax: (addr type-tree) -23651 # . prologue -23652 55/push-ebp -23653 89/<- %ebp 4/r32/esp -23654 # . save registers -23655 51/push-ecx -23656 # eax = 0 -23657 b8/copy-to-eax 0/imm32 -23658 # ecx = t -23659 8b/-> *(ebp+8) 1/r32/ecx -23660 $type-tail:check-atom: -23661 # if t->is-atom? return 0 -23662 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom -23663 0f 85/jump-if-!= $type-tail:end/disp32 -23664 # var tail = t->right -23665 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -23666 89/<- %ecx 0/r32/eax -23667 $type-tail:check-singleton: -23668 # if (tail->right == 0) return tail->left -23669 { -23670 81 7/subop/compare *(ecx+0xc) 0/imm32 # Type-tree-right -23671 75/jump-if-!= break/disp8 -23672 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23673 e9/jump $type-tail:end/disp32 -23674 } -23675 # if tail->right->left is an array-capacity, return tail->left -23676 { -23677 $type-tail:check-array-capacity: -23678 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -23679 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -23680 75/jump-if-!= break/disp8 -23681 $type-tail:check-array-capacity-1: -23682 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -23683 3d/compare-eax-and 0/imm32 -23684 74/jump-if-= break/disp8 -23685 $type-tail:check-array-capacity-2: -23686 (is-simple-mu-type? %eax 9) # array-capacity => eax -23687 3d/compare-eax-and 0/imm32/false -23688 74/jump-if-= break/disp8 -23689 $type-tail:array-capacity: -23690 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23691 eb/jump $type-tail:end/disp8 -23692 } -23693 $type-tail:check-compound-left: -23694 # if !tail->left->is-atom? return tail->left -23695 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23696 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -23697 74/jump-if-= $type-tail:end/disp8 -23698 $type-tail:return-tail: -23699 # return tail -23700 89/<- %eax 1/r32/ecx -23701 $type-tail:end: -23702 # . restore registers -23703 59/pop-to-ecx -23704 # . epilogue -23705 89/<- %esp 5/r32/ebp -23706 5d/pop-to-ebp -23707 c3/return -23708 -23709 type-equal?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean -23710 # . prologue -23711 55/push-ebp -23712 89/<- %ebp 4/r32/esp -23713 # . save registers -23714 51/push-ecx -23715 52/push-edx -23716 53/push-ebx -23717 # ecx = a -23718 8b/-> *(ebp+8) 1/r32/ecx -23719 # edx = b -23720 8b/-> *(ebp+0xc) 2/r32/edx -23721 $type-equal?:compare-addr: -23722 # if (a == b) return true -23723 8b/-> %ecx 0/r32/eax # Var-type -23724 39/compare %edx 0/r32/eax # Var-type -23725 b8/copy-to-eax 1/imm32/true -23726 0f 84/jump-if-= $type-equal?:end/disp32 -23727 $type-equal?:compare-null-a: -23728 # if (a == 0) return false -23729 b8/copy-to-eax 0/imm32/false -23730 81 7/subop/compare %ecx 0/imm32 -23731 0f 84/jump-if-= $type-equal?:end/disp32 -23732 $type-equal?:compare-null-b: -23733 # if (b == 0) return false -23734 81 7/subop/compare %edx 0/imm32 -23735 0f 84/jump-if-= $type-equal?:end/disp32 -23736 $type-equal?:compare-atom-state: -23737 # if (a->is-atom? != b->is-atom?) return false -23738 8b/-> *ecx 3/r32/ebx # Type-tree-is-atom -23739 39/compare *edx 3/r32/ebx # Type-tree-is-atom -23740 b8/copy-to-eax 0/imm32/false -23741 0f 85/jump-if-!= $type-equal?:end/disp32 -23742 # if a->is-atom? return (a->value == b->value) -23743 { -23744 $type-equal?:check-atom: -23745 81 7/subop/compare %ebx 0/imm32/false -23746 74/jump-if-= break/disp8 -23747 $type-equal?:is-atom: -23748 8b/-> *(ecx+4) 0/r32/eax # Type-tree-value -23749 39/compare *(edx+4) 0/r32/eax # Type-tree-value -23750 0f 94/set-if-= %al -23751 81 4/subop/and %eax 0xff/imm32 -23752 e9/jump $type-equal?:end/disp32 -23753 } -23754 $type-equal?:check-left: -23755 # if (!type-equal?(a->left, b->left)) return false -23756 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax -23757 89/<- %ebx 0/r32/eax -23758 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax -23759 (type-equal? %eax %ebx) # => eax -23760 3d/compare-eax-and 0/imm32/false -23761 74/jump-if-= $type-equal?:end/disp8 -23762 $type-equal?:check-right: -23763 # return type-equal?(a->right, b->right) -23764 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax -23765 89/<- %ebx 0/r32/eax -23766 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax -23767 (type-equal? %eax %ebx) # => eax -23768 $type-equal?:end: -23769 # . restore registers -23770 5b/pop-to-ebx -23771 5a/pop-to-edx -23772 59/pop-to-ecx -23773 # . epilogue -23774 89/<- %esp 5/r32/ebp -23775 5d/pop-to-ebp -23776 c3/return -23777 -23778 ####################################################### -23779 # Code-generation -23780 ####################################################### -23781 -23782 == data -23783 -23784 # Global state added to each var record when performing code-generation. -23785 Curr-local-stack-offset: # (addr int) -23786 0/imm32 -23787 -23788 == code -23789 -23790 emit-subx: # out: (addr buffered-file), err: (addr buffered-file), ed: (addr exit-descriptor) -23791 # . prologue -23792 55/push-ebp -23793 89/<- %ebp 4/r32/esp -23794 # . save registers -23795 50/push-eax -23796 # var curr/eax: (addr function) = *Program->functions -23797 (lookup *_Program-functions *_Program-functions->payload) # => eax -23798 { -23799 # if (curr == null) break -23800 3d/compare-eax-and 0/imm32 -23801 0f 84/jump-if-= break/disp32 -23802 (emit-subx-function *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10)) -23803 # curr = lookup(curr->next) -23804 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax -23805 e9/jump loop/disp32 -23806 } -23807 $emit-subx:end: -23808 # . restore registers -23809 58/pop-to-eax -23810 # . epilogue -23811 89/<- %esp 5/r32/ebp -23812 5d/pop-to-ebp -23813 c3/return -23814 -23815 emit-subx-function: # out: (addr buffered-file), f: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -23816 # . prologue -23817 55/push-ebp -23818 89/<- %ebp 4/r32/esp -23819 # some preprocessing -23820 (populate-mu-type-offsets-in-inouts *(ebp+0xc)) -23821 # . save registers -23822 50/push-eax -23823 51/push-ecx -23824 52/push-edx -23825 # initialize some global state -23826 c7 0/subop/copy *Curr-block-depth 1/imm32 # Important: keep this in sync with the parse phase -23827 c7 0/subop/copy *Curr-local-stack-offset 0/imm32 -23828 # ecx = f -23829 8b/-> *(ebp+0xc) 1/r32/ecx -23830 # var vars/edx: (stack (addr var) 256) -23831 81 5/subop/subtract %esp 0xc00/imm32 -23832 68/push 0xc00/imm32/size -23833 68/push 0/imm32/top -23834 89/<- %edx 4/r32/esp -23835 # var name/eax: (addr array byte) = lookup(f->name) -23836 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax -23837 # -23838 (write-buffered *(ebp+8) %eax) -23839 (write-buffered *(ebp+8) ":\n") -23840 (emit-subx-prologue *(ebp+8)) -23841 # var body/eax: (addr block) = lookup(f->body) -23842 (lookup *(ecx+0x18) *(ecx+0x1c)) # Function-body Function-body => eax -23843 # -23844 (emit-subx-block *(ebp+8) %eax %edx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -23845 (emit-subx-epilogue *(ebp+8)) -23846 # TODO: validate that *Curr-block-depth and *Curr-local-stack-offset have -23847 # been cleaned up -23848 $emit-subx-function:end: -23849 # . reclaim locals -23850 81 0/subop/add %esp 0xc08/imm32 -23851 # . restore registers -23852 5a/pop-to-edx -23853 59/pop-to-ecx -23854 58/pop-to-eax -23855 # . epilogue -23856 89/<- %esp 5/r32/ebp -23857 5d/pop-to-ebp -23858 c3/return -23859 -23860 populate-mu-type-offsets-in-inouts: # f: (addr function) -23861 # . prologue -23862 55/push-ebp -23863 89/<- %ebp 4/r32/esp -23864 # . save registers -23865 50/push-eax -23866 51/push-ecx -23867 52/push-edx -23868 53/push-ebx -23869 57/push-edi -23870 # var next-offset/edx: int = 8 -23871 ba/copy-to-edx 8/imm32 -23872 # var curr/ecx: (addr list var) = lookup(f->inouts) -23873 8b/-> *(ebp+8) 1/r32/ecx -23874 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax -23875 89/<- %ecx 0/r32/eax -23876 { -23877 $populate-mu-type-offsets-in-inouts:loop: -23878 81 7/subop/compare %ecx 0/imm32 -23879 74/jump-if-= break/disp8 -23880 # var v/ebx: (addr var) = lookup(curr->value) -23881 (lookup *ecx *(ecx+4)) # List-value List-value => eax -23882 89/<- %ebx 0/r32/eax -23883 #? (lookup *ebx *(ebx+4)) -23884 #? (write-buffered Stderr "setting offset of fn inout ") -23885 #? (write-buffered Stderr %eax) -23886 #? (write-buffered Stderr "@") -23887 #? (write-int32-hex-buffered Stderr %ebx) -23888 #? (write-buffered Stderr " to ") -23889 #? (write-int32-hex-buffered Stderr %edx) -23890 #? (write-buffered Stderr Newline) -23891 #? (flush Stderr) -23892 # v->offset = next-offset -23893 89/<- *(ebx+0x14) 2/r32/edx # Var-offset -23894 # next-offset += size-of(v) -23895 (size-of %ebx) # => eax -23896 01/add-to %edx 0/r32/eax -23897 # curr = lookup(curr->next) -23898 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -23899 89/<- %ecx 0/r32/eax -23900 # -23901 eb/jump loop/disp8 -23902 } -23903 $populate-mu-type-offsets-in-inouts:end: -23904 # . restore registers -23905 5f/pop-to-edi -23906 5b/pop-to-ebx -23907 5a/pop-to-edx -23908 59/pop-to-ecx -23909 58/pop-to-eax -23910 # . epilogue -23911 89/<- %esp 5/r32/ebp -23912 5d/pop-to-ebp -23913 c3/return -23914 -23915 emit-subx-stmt-list: # out: (addr buffered-file), stmts: (addr list stmt), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -23916 # . prologue -23917 55/push-ebp -23918 89/<- %ebp 4/r32/esp -23919 # . save registers -23920 50/push-eax -23921 51/push-ecx -23922 53/push-ebx -23923 56/push-esi -23924 # esi = stmts -23925 8b/-> *(ebp+0xc) 6/r32/esi -23926 # -23927 { -23928 $emit-subx-stmt-list:loop: -23929 81 7/subop/compare %esi 0/imm32 -23930 0f 84/jump-if-= break/disp32 -23931 # var curr-stmt/ecx: (addr stmt) = lookup(stmts->value) -23932 (lookup *esi *(esi+4)) # List-value List-value => eax -23933 89/<- %ecx 0/r32/eax -23934 { -23935 $emit-subx-stmt-list:check-for-block: -23936 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag -23937 75/jump-if-!= break/disp8 -23938 $emit-subx-stmt-list:block: -23939 (emit-subx-block *(ebp+8) %ecx *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -23940 } -23941 { -23942 $emit-subx-stmt-list:check-for-stmt: -23943 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag -23944 0f 85/jump-if-!= break/disp32 -23945 $emit-subx-stmt-list:stmt1: -23946 { -23947 (is-mu-branch? %ecx) # => eax -23948 3d/compare-eax-and 0/imm32/false -23949 0f 84/jump-if-= break/disp32 -23950 $emit-subx-stmt-list:branch-stmt: -23951 +-- 25 lines: # unconditional return ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -23976 +-- 27 lines: # unconditional loops -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -24003 +-- 16 lines: # unconditional breaks ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -24019 +-- 38 lines: # simple conditional branches without a target ------------------------------------------------------------------------------------------------------------------------------------------------------- -24057 +-- 19 lines: # conditional branches with an explicit target ------------------------------------------------------------------------------------------------------------------------------------------------------- -24076 } -24077 $emit-subx-stmt-list:1-to-1: -24078 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x18) *(ebp+0x1c)) -24079 e9/jump $emit-subx-stmt-list:continue/disp32 -24080 } -24081 { -24082 $emit-subx-stmt-list:check-for-var-def: -24083 81 7/subop/compare *ecx 2/imm32/var-def # Stmt-tag -24084 75/jump-if-!= break/disp8 -24085 $emit-subx-stmt-list:var-def: -24086 (emit-subx-var-def *(ebp+8) %ecx) -24087 (push *(ebp+0x10) *(ecx+4)) # Vardef-var -24088 (push *(ebp+0x10) *(ecx+8)) # Vardef-var -24089 (push *(ebp+0x10) 0) # Live-var-register-spilled = 0 for vars on the stack -24090 # -24091 eb/jump $emit-subx-stmt-list:continue/disp8 -24092 } -24093 { -24094 $emit-subx-stmt-list:check-for-reg-var-def: -24095 81 7/subop/compare *ecx 3/imm32/reg-var-def # Stmt-tag -24096 0f 85/jump-if-!= break/disp32 -24097 $emit-subx-stmt-list:reg-var-def: -24098 # TODO: ensure that there's exactly one output -24099 (push-output-and-maybe-emit-spill *(ebp+8) %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -24100 # emit the instruction as usual -24101 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x18) *(ebp+0x1c)) -24102 # -24103 eb/jump $emit-subx-stmt-list:continue/disp8 -24104 } -24105 $emit-subx-stmt-list:continue: -24106 # TODO: raise an error on unrecognized Stmt-tag -24107 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax -24108 89/<- %esi 0/r32/eax -24109 e9/jump loop/disp32 -24110 } -24111 $emit-subx-stmt-list:emit-cleanup: -24112 (emit-cleanup-code-until-depth *(ebp+8) *(ebp+0x10) *Curr-block-depth) -24113 $emit-subx-stmt-list:clean-up: -24114 (clean-up-stack-offset-state *(ebp+0x10) *Curr-block-depth) -24115 (clean-up-blocks *(ebp+0x10) *Curr-block-depth *(ebp+0x14)) -24116 $emit-subx-stmt-list:end: -24117 # . restore registers -24118 5e/pop-to-esi -24119 5b/pop-to-ebx -24120 59/pop-to-ecx -24121 58/pop-to-eax -24122 # . epilogue -24123 89/<- %esp 5/r32/ebp -24124 5d/pop-to-ebp -24125 c3/return -24126 -24127 # 'later-stmts' includes 'stmt', but will behave the same even without it; reg-var-def stmts are guaranteed not to write to function outputs. -24128 push-output-and-maybe-emit-spill: # out: (addr buffered-file), stmt: (addr reg-var-def), vars: (addr stack (handle var)), later-stmts: (addr list stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -24129 # . prologue -24130 55/push-ebp -24131 89/<- %ebp 4/r32/esp -24132 # . save registers -24133 50/push-eax -24134 51/push-ecx -24135 52/push-edx -24136 # ecx = stmt -24137 8b/-> *(ebp+0xc) 1/r32/ecx -24138 # var sv/eax: (addr stmt-var) = lookup(curr-stmt->outputs) -24139 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax -24140 # TODO: assert !sv->is-deref? -24141 # var v/ecx: (addr var) = lookup(sv->value) -24142 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -24143 89/<- %ecx 0/r32/eax -24144 # v->block-depth = *Curr-block-depth -24145 8b/-> *Curr-block-depth 0/r32/eax -24146 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth -24147 #? (write-buffered Stderr "var ") -24148 #? (lookup *ecx *(ecx+4)) -24149 #? (write-buffered Stderr %eax) -24150 #? (write-buffered Stderr " at depth ") -24151 #? (write-int32-hex-buffered Stderr *(ecx+0x10)) -24152 #? (write-buffered Stderr Newline) -24153 #? (flush Stderr) -24154 # ensure that v is in a register -24155 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -24156 0f 84/jump-if-= $push-output-and-maybe-emit-spill:abort/disp32 -24157 # var emit-spill?/edx: boolean = not-yet-spilled-this-block? && will-not-write-some-register?(fn) -24158 (not-yet-spilled-this-block? %ecx *(ebp+0x10)) # => eax -24159 89/<- %edx 0/r32/eax -24160 3d/compare-eax-and 0/imm32/false -24161 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32 -24162 (will-not-write-some-register? %ecx *(ebp+0x14) *(ebp+0x18)) # => eax -24163 89/<- %edx 0/r32/eax -24164 # check emit-spill? -24165 3d/compare-eax-and 0/imm32/false -24166 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32 -24167 # TODO: assert(size-of(output) == 4) -24168 # *Curr-local-stack-offset -= 4 -24169 81 5/subop/subtract *Curr-local-stack-offset 4/imm32 -24170 # emit spill -24171 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax -24172 (emit-push-register *(ebp+8) %eax) -24173 $push-output-and-maybe-emit-spill:push: -24174 8b/-> *(ebp+0xc) 1/r32/ecx -24175 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax -24176 # push(vars, {sv->value, emit-spill?}) -24177 (push *(ebp+0x10) *eax) # Stmt-var-value -24178 (push *(ebp+0x10) *(eax+4)) # Stmt-var-value -24179 (push *(ebp+0x10) %edx) -24180 $push-output-and-maybe-emit-spill:end: -24181 # . restore registers -24182 5a/pop-to-edx -24183 59/pop-to-ecx -24184 58/pop-to-eax -24185 # . epilogue -24186 89/<- %esp 5/r32/ebp -24187 5d/pop-to-ebp -24188 c3/return -24189 -24190 $push-output-and-maybe-emit-spill:abort: -24191 # error("var '" var->name "' initialized from an instruction must live in a register\n") -24192 (write-buffered *(ebp+0x1c) "var '") -24193 (write-buffered *(ebp+0x1c) *eax) # Var-name -24194 (write-buffered *(ebp+0x1c) "' initialized from an instruction must live in a register\n") -24195 (flush *(ebp+0x1c)) -24196 (stop *(ebp+0x20) 1) -24197 # never gets here -24198 -24199 emit-subx-cleanup-and-unconditional-nonlocal-branch: # out: (addr buffered-file), stmt: (addr stmt1), vars: (addr stack live-var) -24200 # . prologue -24201 55/push-ebp -24202 89/<- %ebp 4/r32/esp -24203 # . save registers -24204 50/push-eax -24205 51/push-ecx -24206 # ecx = stmt -24207 8b/-> *(ebp+0xc) 1/r32/ecx -24208 # var target/eax: (addr array byte) = curr-stmt->inouts->value->name -24209 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -24210 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -24211 (lookup *eax *(eax+4)) # Var-name Var-name => eax -24212 # clean up until target block -24213 (emit-cleanup-code-until-target *(ebp+8) *(ebp+0x10) %eax) -24214 # emit jump to target block -24215 (emit-indent *(ebp+8) *Curr-block-depth) -24216 (write-buffered *(ebp+8) "e9/jump ") -24217 (write-buffered *(ebp+8) %eax) -24218 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -24219 (string-starts-with? %eax "break") -24220 3d/compare-eax-and 0/imm32/false -24221 { -24222 74/jump-if-= break/disp8 -24223 (write-buffered *(ebp+8) ":break/disp32\n") -24224 eb/jump $emit-subx-cleanup-and-unconditional-nonlocal-branch:end/disp8 -24225 } -24226 (write-buffered *(ebp+8) ":loop/disp32\n") -24227 $emit-subx-cleanup-and-unconditional-nonlocal-branch:end: -24228 # . restore registers -24229 59/pop-to-ecx -24230 58/pop-to-eax -24231 # . epilogue -24232 89/<- %esp 5/r32/ebp -24233 5d/pop-to-ebp -24234 c3/return -24235 -24236 emit-outputs: # out: (addr buffered-file), return-stmt: (addr stmt1), fn: (addr function) -24237 # pseudocode: -24238 # for every inout, output in return-stmt, fn->outputs -24239 # if inout is a literal -24240 # c7 0/subop/copy %output inout/imm32 -24241 # otherwise -24242 # 8b/-> inout %output -24243 # -24244 # . prologue -24245 55/push-ebp -24246 89/<- %ebp 4/r32/esp -24247 # . save registers -24248 50/push-eax -24249 51/push-ecx -24250 56/push-esi -24251 57/push-edi -24252 # var curr-inout/esi: (addr stmt-var) = return-stmt->inouts -24253 8b/-> *(ebp+0xc) 0/r32/eax -24254 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax -24255 89/<- %esi 0/r32/eax -24256 # var curr-output/edi: (addr list var) = fn->outputs -24257 8b/-> *(ebp+0x10) 0/r32/eax -24258 (lookup *(eax+0x10) *(eax+0x14)) # Function-outputs Function-outputs => eax -24259 89/<- %edi 0/r32/eax -24260 { -24261 $emit-outputs:loop: -24262 81 7/subop/compare %esi 0/imm32 -24263 0f 84/jump-if-= break/disp32 -24264 # emit copy to output register -24265 # var curr-var/ecx = lookup(curr-inout->value) -24266 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax -24267 89/<- %ecx 0/r32/eax -24268 # if curr-var is a literal, emit copy of a literal to the output -24269 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -24270 (is-simple-mu-type? %eax 0) # literal => eax -24271 { -24272 3d/compare-eax-and 0/imm32/false -24273 0f 84/jump-if-= break/disp32 -24274 (emit-indent *(ebp+8) *Curr-block-depth) -24275 (write-buffered *(ebp+8) "c7 0/subop/copy %") -24276 (lookup *edi *(edi+4)) # List-value List-value => eax -24277 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -24278 (write-buffered *(ebp+8) %eax) -24279 (write-buffered *(ebp+8) " ") -24280 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -24281 (write-buffered *(ebp+8) %eax) -24282 (write-buffered *(ebp+8) "/imm32\n") -24283 e9/jump $emit-outputs:continue/disp32 -24284 } -24285 # if the non-literal is a register starting with "x", emit a floating-point copy -24286 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax -24287 { -24288 3d/compare-eax-and 0/imm32 -24289 0f 84/jump-if-= break/disp32 -24290 8a/copy-byte *(eax+4) 0/r32/AL -24291 81 4/subop/and %eax 0xff/imm32 -24292 3d/compare-eax-and 0x78/imm32/x -24293 0f 85/jump-if-!= break/disp32 -24294 (emit-indent *(ebp+8) *Curr-block-depth) -24295 (write-buffered *(ebp+8) "f3 0f 10/->") -24296 (emit-subx-var-as-rm32 *(ebp+8) %esi) -24297 (write-buffered *(ebp+8) " ") -24298 (lookup *edi *(edi+4)) # List-value List-value => eax -24299 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -24300 (get Mu-registers %eax 0xc "Mu-registers") # => eax -24301 (write-int32-hex-buffered *(ebp+8) *eax) -24302 (write-buffered *(ebp+8) "/x32\n") -24303 e9/jump $emit-outputs:continue/disp32 -24304 } -24305 # otherwise emit an integer copy -24306 (emit-indent *(ebp+8) *Curr-block-depth) -24307 (write-buffered *(ebp+8) "8b/->") -24308 (emit-subx-var-as-rm32 *(ebp+8) %esi) -24309 (write-buffered *(ebp+8) " ") -24310 (lookup *edi *(edi+4)) # List-value List-value => eax -24311 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -24312 (get Mu-registers %eax 0xc "Mu-registers") # => eax -24313 (write-int32-hex-buffered *(ebp+8) *eax) -24314 (write-buffered *(ebp+8) "/r32\n") -24315 $emit-outputs:continue: -24316 # curr-inout = curr-inout->next -24317 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -24318 89/<- %esi 0/r32/eax -24319 # curr-output = curr-output->next -24320 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax -24321 89/<- %edi 0/r32/eax -24322 # -24323 e9/jump loop/disp32 -24324 } -24325 $emit-outputs:end: -24326 # . restore registers -24327 5f/pop-to-edi -24328 5e/pop-to-esi -24329 59/pop-to-ecx -24330 58/pop-to-eax -24331 # . epilogue -24332 89/<- %esp 5/r32/ebp -24333 5d/pop-to-ebp -24334 c3/return -24335 -24336 is-mu-branch?: # stmt: (addr stmt1) -> result/eax: boolean -24337 # . prologue -24338 55/push-ebp -24339 89/<- %ebp 4/r32/esp -24340 # . save registers -24341 51/push-ecx -24342 # ecx = lookup(stmt->operation) -24343 8b/-> *(ebp+8) 1/r32/ecx -24344 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -24345 89/<- %ecx 0/r32/eax -24346 # if (stmt->operation starts with "loop") return true -24347 (string-starts-with? %ecx "loop") # => eax -24348 3d/compare-eax-and 0/imm32/false -24349 75/jump-if-not-equal $is-mu-branch?:end/disp8 -24350 # if (stmt->operation starts with "break") return true -24351 (string-starts-with? %ecx "break") # => eax -24352 3d/compare-eax-and 0/imm32/false -24353 75/jump-if-not-equal $is-mu-branch?:end/disp8 -24354 # otherwise return (stmt->operation starts with "return") -24355 (string-starts-with? %ecx "return") # => eax -24356 $is-mu-branch?:end: -24357 # . restore registers -24358 59/pop-to-ecx -24359 # . epilogue -24360 89/<- %esp 5/r32/ebp -24361 5d/pop-to-ebp -24362 c3/return -24363 -24364 emit-reverse-break: # out: (addr buffered-file), stmt: (addr stmt1) -24365 # . prologue -24366 55/push-ebp -24367 89/<- %ebp 4/r32/esp -24368 # . save registers -24369 50/push-eax -24370 # eax = stmt -24371 8b/-> *(ebp+0xc) 0/r32/eax -24372 # -24373 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -24374 (get Reverse-branch %eax 0x10 "reverse-branch: ") # => eax: (addr handle array byte) -24375 (emit-indent *(ebp+8) *Curr-block-depth) -24376 (lookup *eax *(eax+4)) # => eax -24377 (write-buffered *(ebp+8) %eax) -24378 (write-buffered *(ebp+8) " break/disp32\n") -24379 $emit-reverse-break:end: -24380 # . restore registers -24381 58/pop-to-eax -24382 # . epilogue -24383 89/<- %esp 5/r32/ebp -24384 5d/pop-to-ebp -24385 c3/return -24386 -24387 == data -24388 -24389 # Table from Mu branch instructions to the reverse SubX opcodes for them. -24390 Reverse-branch: # (table (handle array byte) (handle array byte)) -24391 # a table is a stream -24392 0x1c0/imm32/write -24393 0/imm32/read -24394 0x1c0/imm32/size -24395 # data -24396 0x11/imm32/alloc-id _string-break-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 -24397 0x11/imm32/alloc-id _string-loop-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 -24398 0x11/imm32/alloc-id _string-break-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 -24399 0x11/imm32/alloc-id _string-loop-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 -24400 0x11/imm32/alloc-id _string-break-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 -24401 0x11/imm32/alloc-id _string-loop-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 -24402 0x11/imm32/alloc-id _string-break-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 -24403 0x11/imm32/alloc-id _string-loop-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 -24404 0x11/imm32/alloc-id _string-break-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -24405 0x11/imm32/alloc-id _string-loop-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -24406 0x11/imm32/alloc-id _string-break-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 -24407 0x11/imm32/alloc-id _string-loop-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 -24408 0x11/imm32/alloc-id _string-break-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 -24409 0x11/imm32/alloc-id _string-loop-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 -24410 0x11/imm32/alloc-id _string-break-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 -24411 0x11/imm32/alloc-id _string-loop-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 -24412 0x11/imm32/alloc-id _string-break-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -24413 0x11/imm32/alloc-id _string-loop-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -24414 0x11/imm32/alloc-id _string-break-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 -24415 0x11/imm32/alloc-id _string-loop-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 -24416 0x11/imm32/alloc-id _string-break-if-float</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 -24417 0x11/imm32/alloc-id _string-loop-if-float</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 -24418 0x11/imm32/alloc-id _string-break-if-float>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 -24419 0x11/imm32/alloc-id _string-loop-if-float>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 -24420 0x11/imm32/alloc-id _string-break-if-float<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -24421 0x11/imm32/alloc-id _string-loop-if-float<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 -24422 0x11/imm32/alloc-id _string-break-if-float>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 -24423 0x11/imm32/alloc-id _string-loop-if-float>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 -24424 -24425 == code -24426 -24427 emit-unconditional-jump-to-depth: # out: (addr buffered-file), vars: (addr stack live-var), depth: int, label-suffix: (addr array byte) -24428 # . prologue -24429 55/push-ebp -24430 89/<- %ebp 4/r32/esp -24431 # . save registers -24432 50/push-eax -24433 51/push-ecx -24434 52/push-edx -24435 53/push-ebx -24436 56/push-esi -24437 # ecx = vars -24438 8b/-> *(ebp+0xc) 1/r32/ecx -24439 # var eax: int = vars->top -24440 8b/-> *ecx 0/r32/eax -24441 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] -24442 8d/copy-address *(ecx+eax-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size -24443 # var min/ecx: (addr handle var) = vars->data -24444 8d/copy-address *(ecx+8) 1/r32/ecx -24445 # edx = depth -24446 8b/-> *(ebp+0x10) 2/r32/edx -24447 { -24448 $emit-unconditional-jump-to-depth:loop: -24449 # if (curr < min) break -24450 39/compare %esi 1/r32/ecx -24451 0f 82/jump-if-addr< break/disp32 -24452 # var v/ebx: (addr var) = lookup(*curr) -24453 (lookup *esi *(esi+4)) # => eax -24454 89/<- %ebx 0/r32/eax -24455 # if (v->block-depth < until-block-depth) break -24456 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth -24457 0f 8c/jump-if-< break/disp32 -24458 { -24459 $emit-unconditional-jump-to-depth:check: -24460 # if v->block-depth != until-block-depth, continue -24461 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth -24462 0f 85/jump-if-!= break/disp32 -24463 $emit-unconditional-jump-to-depth:depth-found: -24464 # if v is not a literal, continue -24465 (size-of %ebx) # => eax -24466 3d/compare-eax-and 0/imm32 -24467 0f 85/jump-if-!= break/disp32 -24468 $emit-unconditional-jump-to-depth:label-found: -24469 # emit unconditional jump, then return -24470 (emit-indent *(ebp+8) *Curr-block-depth) -24471 (write-buffered *(ebp+8) "e9/jump ") -24472 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -24473 (write-buffered *(ebp+8) %eax) -24474 (write-buffered *(ebp+8) ":") -24475 (write-buffered *(ebp+8) *(ebp+0x14)) -24476 (write-buffered *(ebp+8) "/disp32\n") -24477 eb/jump $emit-unconditional-jump-to-depth:end/disp8 -24478 } -24479 # curr -= 12 -24480 81 5/subop/subtract %esi 0xc/imm32 -24481 e9/jump loop/disp32 -24482 } -24483 # TODO: error if no label at 'depth' was found -24484 $emit-unconditional-jump-to-depth:end: -24485 # . restore registers -24486 5e/pop-to-esi -24487 5b/pop-to-ebx -24488 5a/pop-to-edx -24489 59/pop-to-ecx -24490 58/pop-to-eax -24491 # . epilogue -24492 89/<- %esp 5/r32/ebp -24493 5d/pop-to-ebp -24494 c3/return -24495 -24496 # emit clean-up code for 'vars' until some block depth -24497 # doesn't actually modify 'vars' so we need traverse manually inside the stack -24498 emit-cleanup-code-until-depth: # out: (addr buffered-file), vars: (addr stack live-var), until-block-depth: int -24499 # . prologue -24500 55/push-ebp -24501 89/<- %ebp 4/r32/esp -24502 # . save registers -24503 50/push-eax -24504 51/push-ecx -24505 52/push-edx -24506 53/push-ebx -24507 56/push-esi -24508 #? (write-buffered Stderr "--- cleanup\n") -24509 #? (flush Stderr) -24510 # ecx = vars -24511 8b/-> *(ebp+0xc) 1/r32/ecx -24512 # var esi: int = vars->top -24513 8b/-> *ecx 6/r32/esi -24514 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] -24515 8d/copy-address *(ecx+esi-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size -24516 # var min/ecx: (addr handle var) = vars->data -24517 81 0/subop/add %ecx 8/imm32 -24518 # edx = until-block-depth -24519 8b/-> *(ebp+0x10) 2/r32/edx -24520 { -24521 $emit-cleanup-code-until-depth:loop: -24522 # if (curr < min) break -24523 39/compare %esi 1/r32/ecx -24524 0f 82/jump-if-addr< break/disp32 -24525 # var v/ebx: (addr var) = lookup(*curr) -24526 (lookup *esi *(esi+4)) # => eax -24527 89/<- %ebx 0/r32/eax -24528 #? (lookup *ebx *(ebx+4)) # Var-name -24529 #? (write-buffered Stderr "var ") -24530 #? (write-buffered Stderr %eax) -24531 #? (write-buffered Stderr Newline) -24532 #? (flush Stderr) -24533 # if (v->block-depth < until-block-depth) break -24534 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth -24535 0f 8c/jump-if-< break/disp32 -24536 # if v is in a register -24537 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register -24538 { -24539 0f 84/jump-if-= break/disp32 -24540 { -24541 $emit-cleanup-code-until-depth:check-for-previous-spill: -24542 8b/-> *(esi+8) 0/r32/eax # Live-var-register-spilled -24543 3d/compare-eax-and 0/imm32/false -24544 74/jump-if-= break/disp8 -24545 $emit-cleanup-code-until-depth:reclaim-var-in-register: -24546 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -24547 (emit-pop-register *(ebp+8) %eax) -24548 } -24549 eb/jump $emit-cleanup-code-until-depth:continue/disp8 -24550 } -24551 # otherwise v is on the stack -24552 { -24553 75/jump-if-!= break/disp8 -24554 $emit-cleanup-code-until-depth:var-on-stack: -24555 (size-of %ebx) # => eax -24556 # don't emit code for labels -24557 3d/compare-eax-and 0/imm32 -24558 74/jump-if-= break/disp8 -24559 $emit-cleanup-code-until-depth:reclaim-var-on-stack: -24560 (emit-indent *(ebp+8) *Curr-block-depth) -24561 (write-buffered *(ebp+8) "81 0/subop/add %esp ") -24562 (write-int32-hex-buffered *(ebp+8) %eax) -24563 (write-buffered *(ebp+8) "/imm32\n") -24564 } -24565 $emit-cleanup-code-until-depth:continue: -24566 # curr -= 12 -24567 81 5/subop/subtract %esi 0xc/imm32 -24568 e9/jump loop/disp32 -24569 } -24570 $emit-cleanup-code-until-depth:end: -24571 # . restore registers -24572 5e/pop-to-esi -24573 5b/pop-to-ebx -24574 5a/pop-to-edx -24575 59/pop-to-ecx -24576 58/pop-to-eax -24577 # . epilogue -24578 89/<- %esp 5/r32/ebp -24579 5d/pop-to-ebp -24580 c3/return -24581 -24582 # emit clean-up code for 'vars' that don't conflict with output registers -24583 # doesn't actually modify 'vars' so we need traverse manually inside the stack -24584 emit-cleanup-code-for-non-outputs: # out: (addr buffered-file), vars: (addr stack live-var), fn: (addr function) -24585 # . prologue -24586 55/push-ebp -24587 89/<- %ebp 4/r32/esp -24588 # . save registers -24589 50/push-eax -24590 51/push-ecx -24591 52/push-edx -24592 53/push-ebx -24593 56/push-esi -24594 57/push-edi -24595 # ecx = vars -24596 8b/-> *(ebp+0xc) 1/r32/ecx -24597 # var esi: int = vars->top -24598 8b/-> *ecx 6/r32/esi -24599 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] -24600 8d/copy-address *(ecx+esi-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size -24601 # var min/ecx: (addr handle var) = vars->data -24602 81 0/subop/add %ecx 8/imm32 +23464 74/jump-if-= break/disp8 +23465 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23466 # if target-type->right is null, target-type = target-type->left +23467 81 7/subop/compare *(eax+0xc) 0/imm32 # Type-tree-right +23468 { +23469 75/jump-if-!= break/disp8 +23470 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +23471 } +23472 89/<- %ebx 0/r32/eax +23473 } +23474 $check-mu-populate-stream-stmt:check-target-type-addr: +23475 # if target-type is not addr, abort +23476 (is-mu-addr-type? %ebx) # => eax +23477 3d/compare-eax-and 0/imm32/false +23478 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 +23479 # if target-type->right is an atom, abort +23480 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23481 89/<- %ebx 0/r32/eax +23482 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +23483 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 +23484 $check-mu-populate-stream-stmt:check-target-type-handle: +23485 # if target-type->right->left is not handle, abort +23486 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +23487 (is-simple-mu-type? %eax 4) # handle => eax +23488 3d/compare-eax-and 0/imm32/false +23489 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 +23490 # if target-type->right->right is an atom, abort +23491 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23492 89/<- %ebx 0/r32/eax +23493 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +23494 0f 85/jump-if-!= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 +23495 $check-mu-populate-stream-stmt:check-target-type-stream: +23496 # if target-type->right->right->left is not stream, abort +23497 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +23498 (is-simple-mu-type? %eax 0xb) # stream => eax +23499 3d/compare-eax-and 0/imm32/false +23500 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-target-type/disp32 +23501 $check-mu-populate-stream-stmt:check-length-type: +23502 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +23503 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +23504 89/<- %ebx 0/r32/eax +23505 (is-simple-mu-type? %ebx 0) # literal => eax +23506 3d/compare-eax-and 0/imm32/false +23507 75/jump-if-!= $check-mu-populate-stream-stmt:end/disp8 +23508 (is-simple-mu-type? %ebx 1) # int => eax +23509 3d/compare-eax-and 0/imm32/false +23510 0f 84/jump-if-= $check-mu-populate-stream-stmt:error-invalid-length-type/disp32 +23511 $check-mu-populate-stream-stmt:end: +23512 # . restore registers +23513 5f/pop-to-edi +23514 5e/pop-to-esi +23515 5b/pop-to-ebx +23516 58/pop-to-eax +23517 # . epilogue +23518 89/<- %esp 5/r32/ebp +23519 5d/pop-to-ebp +23520 c3/return +23521 +23522 $check-mu-populate-stream-stmt:error-incorrect-inouts: +23523 (write-buffered *(ebp+0x10) "fn ") +23524 8b/-> *(ebp+0xc) 0/r32/eax +23525 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23526 (write-buffered *(ebp+0x10) %eax) +23527 (write-buffered *(ebp+0x10) ": stmt 'populate-stream' must have two inouts\n") +23528 (flush *(ebp+0x10)) +23529 (stop *(ebp+0x14) 1) +23530 # never gets here +23531 +23532 $check-mu-populate-stream-stmt:error-too-many-outputs: +23533 (write-buffered *(ebp+0x10) "fn ") +23534 8b/-> *(ebp+0xc) 0/r32/eax +23535 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23536 (write-buffered *(ebp+0x10) %eax) +23537 (write-buffered *(ebp+0x10) ": stmt 'populate-stream' must not have any outputs\n") +23538 (flush *(ebp+0x10)) +23539 (stop *(ebp+0x14) 1) +23540 # never gets here +23541 +23542 $check-mu-populate-stream-stmt:error-invalid-target-type: +23543 (write-buffered *(ebp+0x10) "fn ") +23544 8b/-> *(ebp+0xc) 0/r32/eax +23545 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23546 (write-buffered *(ebp+0x10) %eax) +23547 (write-buffered *(ebp+0x10) ": stmt populate-stream: first inout '") +23548 (lookup *edi *(edi+4)) # Stmt-var-value Stmt-var-value => eax +23549 (lookup *eax *(eax+4)) # Var-name Var-name => eax +23550 (write-buffered *(ebp+0x10) %eax) +23551 (write-buffered *(ebp+0x10) "' must have type (addr handle stream ...)\n") +23552 (flush *(ebp+0x10)) +23553 (stop *(ebp+0x14) 1) +23554 # never gets here +23555 +23556 $check-mu-populate-stream-stmt:error-invalid-length-type: +23557 (write-buffered *(ebp+0x10) "fn ") +23558 8b/-> *(ebp+0xc) 0/r32/eax +23559 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23560 (write-buffered *(ebp+0x10) %eax) +23561 (write-buffered *(ebp+0x10) ": stmt populate-stream: second inout '") +23562 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +23563 (lookup *eax *(eax+4)) # Var-name Var-name => eax +23564 (write-buffered *(ebp+0x10) %eax) +23565 (write-buffered *(ebp+0x10) "' must be an int\n") +23566 (flush *(ebp+0x10)) +23567 (stop *(ebp+0x14) 1) +23568 # never gets here +23569 +23570 check-mu-read-from-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +23571 # . prologue +23572 55/push-ebp +23573 89/<- %ebp 4/r32/esp +23574 # . save registers +23575 50/push-eax +23576 51/push-ecx +23577 52/push-edx +23578 53/push-ebx +23579 56/push-esi +23580 57/push-edi +23581 # esi = stmt +23582 8b/-> *(ebp+8) 6/r32/esi +23583 # - check for 0 inouts +23584 # var base/ecx: (addr var) = stmt->inouts->value +23585 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23586 $check-mu-read-from-stream-stmt:check-no-inouts: +23587 3d/compare-eax-and 0/imm32 +23588 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-too-few-inouts/disp32 +23589 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +23590 89/<- %ecx 0/r32/eax +23591 # - check base type is (addr stream T) +23592 # var base-type/ebx: (addr type-tree) = lookup(base->type) +23593 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +23594 89/<- %ebx 0/r32/eax +23595 $check-mu-read-from-stream-stmt:check-base-is-compound: +23596 # if base-type is an atom, abort +23597 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +23598 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-invalid-base-type/disp32 +23599 $check-mu-read-from-stream-stmt:check-base-is-addr: +23600 # if type->left not addr, abort +23601 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +23602 (is-simple-mu-type? %eax 2) # addr => eax +23603 3d/compare-eax-and 0/imm32/false +23604 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-invalid-base-type/disp32 +23605 $check-mu-read-from-stream-stmt:check-base-is-addr-to-stream: +23606 # base-type = base-type->right +23607 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23608 89/<- %ebx 0/r32/eax +23609 # ensure base-type->left == stream +23610 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +23611 (is-simple-mu-type? %eax 0xb) # stream => eax +23612 3d/compare-eax-and 0/imm32/false +23613 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-invalid-base-type/disp32 +23614 # - check target type is (addr T) +23615 # var target/ecx: (addr stmt-var) = stmt->inouts->next->value +23616 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23617 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +23618 $check-mu-read-from-stream-stmt:check-single-inout: +23619 3d/compare-eax-and 0/imm32 +23620 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-too-few-inouts/disp32 +23621 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +23622 89/<- %ecx 0/r32/eax +23623 # var target-type/edx: (addr type-tree) +23624 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +23625 89/<- %edx 0/r32/eax +23626 # if target-type is an atom, it must be a literal or int +23627 $check-mu-read-from-stream-stmt:check-target-is-compound: +23628 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom +23629 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-target-type-not-address/disp32 +23630 $check-mu-read-from-stream-stmt:check-target-type: +23631 # target type must start with (addr ...) +23632 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +23633 (is-simple-mu-type? %eax 2) # addr => eax +23634 3d/compare-eax-and 0/imm32/false +23635 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-target-type-not-address/disp32 +23636 # if tail(base-type) != tail(target-type) abort +23637 (type-tail %ebx) # => eax +23638 89/<- %ebx 0/r32/eax +23639 (type-tail %edx) # => eax +23640 (type-equal? %ebx %eax) # => eax +23641 3d/compare-eax-and 0/imm32/false +23642 0f 84/jump-if-= $check-mu-read-from-stream-stmt:error-invalid-target-type/disp32 +23643 $check-mu-read-from-stream-stmt:check-too-many-inouts: +23644 # - check for too many inouts +23645 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23646 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +23647 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +23648 3d/compare-eax-and 0/imm32/false +23649 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-too-many-inouts/disp32 +23650 $check-mu-read-from-stream-stmt:check-unexpected-output: +23651 # - check for any output +23652 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +23653 3d/compare-eax-and 0/imm32/false +23654 0f 85/jump-if-!= $check-mu-read-from-stream-stmt:error-unexpected-output/disp32 +23655 $check-mu-read-from-stream-stmt:end: +23656 # . restore registers +23657 5f/pop-to-edi +23658 5e/pop-to-esi +23659 5b/pop-to-ebx +23660 5a/pop-to-edx +23661 59/pop-to-ecx +23662 58/pop-to-eax +23663 # . epilogue +23664 89/<- %esp 5/r32/ebp +23665 5d/pop-to-ebp +23666 c3/return +23667 +23668 $check-mu-read-from-stream-stmt:error-invalid-base-type: +23669 (write-buffered *(ebp+0x10) "fn ") +23670 8b/-> *(ebp+0xc) 0/r32/eax +23671 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23672 (write-buffered *(ebp+0x10) %eax) +23673 (write-buffered *(ebp+0x10) ": stmt read-from-stream: var '") +23674 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +23675 (write-buffered *(ebp+0x10) %eax) +23676 (write-buffered *(ebp+0x10) "' must be an addr to a stream\n") +23677 (flush *(ebp+0x10)) +23678 (stop *(ebp+0x14) 1) +23679 # never gets here +23680 +23681 $check-mu-read-from-stream-stmt:error-too-few-inouts: +23682 (write-buffered *(ebp+0x10) "fn ") +23683 8b/-> *(ebp+0xc) 0/r32/eax +23684 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23685 (write-buffered *(ebp+0x10) %eax) +23686 (write-buffered *(ebp+0x10) ": stmt read-from-stream: too few inouts (2 required)\n") +23687 (flush *(ebp+0x10)) +23688 (stop *(ebp+0x14) 1) +23689 # never gets here +23690 +23691 $check-mu-read-from-stream-stmt:error-target-type-not-address: +23692 (write-buffered *(ebp+0x10) "fn ") +23693 8b/-> *(ebp+0xc) 0/r32/eax +23694 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23695 (write-buffered *(ebp+0x10) %eax) +23696 (write-buffered *(ebp+0x10) ": stmt read-from-stream: target '") +23697 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +23698 (write-buffered *(ebp+0x10) %eax) +23699 (write-buffered *(ebp+0x10) "' must be an addr\n") +23700 (flush *(ebp+0x10)) +23701 (stop *(ebp+0x14) 1) +23702 # never gets here +23703 +23704 $check-mu-read-from-stream-stmt:error-invalid-target-type: +23705 (write-buffered *(ebp+0x10) "fn ") +23706 8b/-> *(ebp+0xc) 0/r32/eax +23707 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23708 (write-buffered *(ebp+0x10) %eax) +23709 (write-buffered *(ebp+0x10) ": stmt read-from-stream: second inout '") +23710 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +23711 (write-buffered *(ebp+0x10) %eax) +23712 (write-buffered *(ebp+0x10) "' does not have the right type\n") +23713 (flush *(ebp+0x10)) +23714 (stop *(ebp+0x14) 1) +23715 # never gets here +23716 +23717 $check-mu-read-from-stream-stmt:error-too-many-inouts: +23718 (write-buffered *(ebp+0x10) "fn ") +23719 8b/-> *(ebp+0xc) 0/r32/eax +23720 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23721 (write-buffered *(ebp+0x10) %eax) +23722 (write-buffered *(ebp+0x10) ": stmt read-from-stream: too many inouts (2 required)\n") +23723 (flush *(ebp+0x10)) +23724 (stop *(ebp+0x14) 1) +23725 # never gets here +23726 +23727 $check-mu-read-from-stream-stmt:error-unexpected-output: +23728 (write-buffered *(ebp+0x10) "fn ") +23729 8b/-> *(ebp+0xc) 0/r32/eax +23730 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23731 (write-buffered *(ebp+0x10) %eax) +23732 (write-buffered *(ebp+0x10) ": stmt read-from-stream: unexpected output\n") +23733 (flush *(ebp+0x10)) +23734 (stop *(ebp+0x14) 1) +23735 # never gets here +23736 +23737 check-mu-write-to-stream-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +23738 # . prologue +23739 55/push-ebp +23740 89/<- %ebp 4/r32/esp +23741 # . save registers +23742 50/push-eax +23743 51/push-ecx +23744 52/push-edx +23745 53/push-ebx +23746 56/push-esi +23747 57/push-edi +23748 # esi = stmt +23749 8b/-> *(ebp+8) 6/r32/esi +23750 # - check for 0 inouts +23751 # var base/ecx: (addr var) = stmt->inouts->value +23752 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23753 $check-mu-write-to-stream-stmt:check-no-inouts: +23754 3d/compare-eax-and 0/imm32 +23755 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-too-few-inouts/disp32 +23756 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +23757 89/<- %ecx 0/r32/eax +23758 # - check base type is (addr stream T) +23759 # var base-type/ebx: (addr type-tree) = lookup(base->type) +23760 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +23761 89/<- %ebx 0/r32/eax +23762 $check-mu-write-to-stream-stmt:check-base-is-compound: +23763 # if base-type is an atom, abort +23764 81 7/subop/compare *ebx 0/imm32/false # Type-tree-is-atom +23765 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-invalid-base-type/disp32 +23766 $check-mu-write-to-stream-stmt:check-base-is-addr: +23767 # if type->left not addr, abort +23768 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +23769 (is-simple-mu-type? %eax 2) # addr => eax +23770 3d/compare-eax-and 0/imm32/false +23771 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-invalid-base-type/disp32 +23772 $check-mu-write-to-stream-stmt:check-base-is-addr-to-stream: +23773 # base-type = base-type->right +23774 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23775 89/<- %ebx 0/r32/eax +23776 # ensure base-type->left == stream +23777 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +23778 (is-simple-mu-type? %eax 0xb) # stream => eax +23779 3d/compare-eax-and 0/imm32/false +23780 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-invalid-base-type/disp32 +23781 # - check target type is (addr T) +23782 # var target/ecx: (addr stmt-var) = stmt->inouts->next->value +23783 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23784 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +23785 $check-mu-write-to-stream-stmt:check-single-inout: +23786 3d/compare-eax-and 0/imm32 +23787 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-too-few-inouts/disp32 +23788 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +23789 89/<- %ecx 0/r32/eax +23790 # var target-type/edx: (addr type-tree) +23791 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +23792 89/<- %edx 0/r32/eax +23793 # if target-type is an atom, it must be a literal or int +23794 $check-mu-write-to-stream-stmt:check-target-is-compound: +23795 81 7/subop/compare *edx 0/imm32/false # Type-tree-is-atom +23796 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-target-type-not-address/disp32 +23797 $check-mu-write-to-stream-stmt:check-target-type: +23798 # target type must start with (addr ...) +23799 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +23800 (is-simple-mu-type? %eax 2) # addr => eax +23801 3d/compare-eax-and 0/imm32/false +23802 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-target-type-not-address/disp32 +23803 # if tail(base-type) != tail(target-type) abort +23804 (type-tail %ebx) # => eax +23805 89/<- %ebx 0/r32/eax +23806 (type-tail %edx) # => eax +23807 (type-equal? %ebx %eax) # => eax +23808 3d/compare-eax-and 0/imm32/false +23809 0f 84/jump-if-= $check-mu-write-to-stream-stmt:error-invalid-target-type/disp32 +23810 $check-mu-write-to-stream-stmt:check-too-many-inouts: +23811 # - check for too many inouts +23812 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23813 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +23814 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +23815 3d/compare-eax-and 0/imm32/false +23816 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-too-many-inouts/disp32 +23817 $check-mu-write-to-stream-stmt:check-unexpected-output: +23818 # - check for any output +23819 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +23820 3d/compare-eax-and 0/imm32/false +23821 0f 85/jump-if-!= $check-mu-write-to-stream-stmt:error-unexpected-output/disp32 +23822 $check-mu-write-to-stream-stmt:end: +23823 # . restore registers +23824 5f/pop-to-edi +23825 5e/pop-to-esi +23826 5b/pop-to-ebx +23827 5a/pop-to-edx +23828 59/pop-to-ecx +23829 58/pop-to-eax +23830 # . epilogue +23831 89/<- %esp 5/r32/ebp +23832 5d/pop-to-ebp +23833 c3/return +23834 +23835 $check-mu-write-to-stream-stmt:error-invalid-base-type: +23836 (write-buffered *(ebp+0x10) "fn ") +23837 8b/-> *(ebp+0xc) 0/r32/eax +23838 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23839 (write-buffered *(ebp+0x10) %eax) +23840 (write-buffered *(ebp+0x10) ": stmt write-to-stream: var '") +23841 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +23842 (write-buffered *(ebp+0x10) %eax) +23843 (write-buffered *(ebp+0x10) "' must be an addr to a stream\n") +23844 (flush *(ebp+0x10)) +23845 (stop *(ebp+0x14) 1) +23846 # never gets here +23847 +23848 $check-mu-write-to-stream-stmt:error-too-few-inouts: +23849 (write-buffered *(ebp+0x10) "fn ") +23850 8b/-> *(ebp+0xc) 0/r32/eax +23851 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23852 (write-buffered *(ebp+0x10) %eax) +23853 (write-buffered *(ebp+0x10) ": stmt write-to-stream: too few inouts (2 required)\n") +23854 (flush *(ebp+0x10)) +23855 (stop *(ebp+0x14) 1) +23856 # never gets here +23857 +23858 $check-mu-write-to-stream-stmt:error-target-type-not-address: +23859 (write-buffered *(ebp+0x10) "fn ") +23860 8b/-> *(ebp+0xc) 0/r32/eax +23861 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23862 (write-buffered *(ebp+0x10) %eax) +23863 (write-buffered *(ebp+0x10) ": stmt write-to-stream: target '") +23864 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +23865 (write-buffered *(ebp+0x10) %eax) +23866 (write-buffered *(ebp+0x10) "' must be an addr\n") +23867 (flush *(ebp+0x10)) +23868 (stop *(ebp+0x14) 1) +23869 # never gets here +23870 +23871 $check-mu-write-to-stream-stmt:error-invalid-target-type: +23872 (write-buffered *(ebp+0x10) "fn ") +23873 8b/-> *(ebp+0xc) 0/r32/eax +23874 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23875 (write-buffered *(ebp+0x10) %eax) +23876 (write-buffered *(ebp+0x10) ": stmt write-to-stream: second inout '") +23877 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +23878 (write-buffered *(ebp+0x10) %eax) +23879 (write-buffered *(ebp+0x10) "' does not have the right type\n") +23880 (flush *(ebp+0x10)) +23881 (stop *(ebp+0x14) 1) +23882 # never gets here +23883 +23884 $check-mu-write-to-stream-stmt:error-too-many-inouts: +23885 (write-buffered *(ebp+0x10) "fn ") +23886 8b/-> *(ebp+0xc) 0/r32/eax +23887 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23888 (write-buffered *(ebp+0x10) %eax) +23889 (write-buffered *(ebp+0x10) ": stmt write-to-stream: too many inouts (2 required)\n") +23890 (flush *(ebp+0x10)) +23891 (stop *(ebp+0x14) 1) +23892 # never gets here +23893 +23894 $check-mu-write-to-stream-stmt:error-unexpected-output: +23895 (write-buffered *(ebp+0x10) "fn ") +23896 8b/-> *(ebp+0xc) 0/r32/eax +23897 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23898 (write-buffered *(ebp+0x10) %eax) +23899 (write-buffered *(ebp+0x10) ": stmt write-to-stream: unexpected output\n") +23900 (flush *(ebp+0x10)) +23901 (stop *(ebp+0x14) 1) +23902 # never gets here +23903 +23904 check-mu-convert-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +23905 # . prologue +23906 55/push-ebp +23907 89/<- %ebp 4/r32/esp +23908 # . save registers +23909 $check-mu-convert-stmt:end: +23910 # . restore registers +23911 # . epilogue +23912 89/<- %esp 5/r32/ebp +23913 5d/pop-to-ebp +23914 c3/return +23915 +23916 check-mu-call: # stmt: (addr stmt), callee: (addr function), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +23917 # . prologue +23918 55/push-ebp +23919 89/<- %ebp 4/r32/esp +23920 # var type-parameters: (addr table (handle array byte) (addr type-tree) 8) +23921 68/push 0/imm32 +23922 # var type-parameters-storage: (table (handle array byte) (addr type-tree) 8) +23923 81 5/subop/subtract %esp 0x60/imm32 +23924 68/push 0x60/imm32/size +23925 68/push 0/imm32/read +23926 68/push 0/imm32/write +23927 # save a pointer to type-parameters-storage at type-parameters +23928 89/<- *(ebp-4) 4/r32/esp +23929 (clear-stream *(ebp-4)) +23930 # . save registers +23931 50/push-eax +23932 51/push-ecx +23933 52/push-edx +23934 53/push-ebx +23935 56/push-esi +23936 57/push-edi +23937 # esi = stmt +23938 8b/-> *(ebp+8) 6/r32/esi +23939 # edi = callee +23940 8b/-> *(ebp+0xc) 7/r32/edi +23941 # var inouts/ecx: (addr stmt-var) = lookup(stmt->inouts) +23942 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +23943 89/<- %ecx 0/r32/eax +23944 # var expected/edx: (addr list var) = lookup(f->inouts) +23945 (lookup *(edi+8) *(edi+0xc)) # Function-inouts Function-inouts => eax +23946 89/<- %edx 0/r32/eax +23947 { +23948 $check-mu-call:check-for-inouts: +23949 # if (inouts == 0) break +23950 81 7/subop/compare %ecx 0/imm32 +23951 0f 84/jump-if-= break/disp32 +23952 # if (expected == 0) error +23953 81 7/subop/compare %edx 0/imm32 +23954 0f 84/jump-if-= break/disp32 +23955 $check-mu-call:check-null-addr: +23956 # if (inouts->value->name == "0") continue +23957 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +23958 (lookup *eax *(eax+4)) # Var-name Var-name => eax +23959 (string-equal? %eax "0") # => eax +23960 3d/compare-eax-and 0/imm32/false +23961 0f 85/jump-if-!= $check-mu-call:continue-to-next-inout/disp32 +23962 $check-mu-call:check-inout-type: +23963 # var t/ebx: (addr type-tree) = inouts->value->type +23964 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +23965 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +23966 89/<- %ebx 0/r32/eax +23967 # if (inouts->is-deref?) t = t->right +23968 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +23969 { +23970 74/jump-if-= break/disp8 +23971 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +23972 89/<- %ebx 0/r32/eax +23973 # if t->right is null, t = t->left +23974 81 7/subop/compare *(ebx+0xc) 0/imm32 # Type-tree-right +23975 75/jump-if-!= break/disp8 +23976 (lookup *(ebx+4) *(ebx+8)) # Type-tree-left Type-tree-left => eax +23977 89/<- %ebx 0/r32/eax +23978 } +23979 # var v2/eax: (addr v) = lookup(expected->value) +23980 (lookup *edx *(edx+4)) # List-value List-value => eax +23981 # var t2/eax: (addr type-tree) = lookup(v2->type) +23982 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +23983 # if (t != t2) error +23984 (type-match? %eax %ebx *(ebp-4)) # => eax +23985 3d/compare-eax-and 0/imm32/false +23986 { +23987 0f 85/jump-if-!= break/disp32 +23988 (write-buffered *(ebp+0x14) "fn ") +23989 8b/-> *(ebp+0x10) 0/r32/eax +23990 (lookup *eax *(eax+4)) # Function-name Function-name => eax +23991 (write-buffered *(ebp+0x14) %eax) +23992 (write-buffered *(ebp+0x14) ": call ") +23993 (lookup *edi *(edi+4)) # Function-name Function-name => eax +23994 (write-buffered *(ebp+0x14) %eax) +23995 (write-buffered *(ebp+0x14) ": type for inout '") +23996 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +23997 (lookup *eax *(eax+4)) # Var-name Var-name => eax +23998 (write-buffered *(ebp+0x14) %eax) +23999 (write-buffered *(ebp+0x14) "' is not right\n") +24000 (flush *(ebp+0x14)) +24001 (stop *(ebp+0x18) 1) +24002 } +24003 $check-mu-call:continue-to-next-inout: +24004 # inouts = lookup(inouts->next) +24005 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +24006 89/<- %ecx 0/r32/eax +24007 # expected = lookup(expected->next) +24008 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax +24009 89/<- %edx 0/r32/eax +24010 # +24011 e9/jump loop/disp32 +24012 } +24013 $check-mu-call:check-inout-count: +24014 # if (inouts == expected) proceed +24015 39/compare %ecx 2/r32/edx +24016 { +24017 0f 84/jump-if-= break/disp32 +24018 # exactly one of the two is null +24019 # if (inouts == 0) error("too many inouts") +24020 { +24021 81 7/subop/compare %ecx 0/imm32 +24022 0f 84/jump-if-= break/disp32 +24023 (write-buffered *(ebp+0x14) "fn ") +24024 8b/-> *(ebp+0x10) 0/r32/eax +24025 (lookup *eax *(eax+4)) # Function-name Function-name => eax +24026 (write-buffered *(ebp+0x14) %eax) +24027 (write-buffered *(ebp+0x14) ": call ") +24028 (lookup *edi *(edi+4)) # Function-name Function-name => eax +24029 (write-buffered *(ebp+0x14) %eax) +24030 (write-buffered *(ebp+0x14) ": too many inouts\n") +24031 (flush *(ebp+0x14)) +24032 (stop *(ebp+0x18) 1) +24033 } +24034 # if (expected == 0) error("too few inouts") +24035 { +24036 81 7/subop/compare %edx 0/imm32 +24037 0f 84/jump-if-= break/disp32 +24038 (write-buffered *(ebp+0x14) "fn ") +24039 8b/-> *(ebp+0x10) 0/r32/eax +24040 (lookup *eax *(eax+4)) # Function-name Function-name => eax +24041 (write-buffered *(ebp+0x14) %eax) +24042 (write-buffered *(ebp+0x14) ": call ") +24043 (lookup *edi *(edi+4)) # Function-name Function-name => eax +24044 (write-buffered *(ebp+0x14) %eax) +24045 (write-buffered *(ebp+0x14) ": too few inouts\n") +24046 (flush *(ebp+0x14)) +24047 (stop *(ebp+0x18) 1) +24048 } +24049 } +24050 $check-mu-call:check-outputs: +24051 # var outputs/ecx: (addr stmt-var) = lookup(stmt->outputs) +24052 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +24053 89/<- %ecx 0/r32/eax +24054 # var expected/edx: (addr list var) = lookup(f->outputs) +24055 (lookup *(edi+0x10) *(edi+0x14)) # Function-outputs Function-outputs => eax +24056 89/<- %edx 0/r32/eax +24057 { +24058 $check-mu-call:check-for-outputs: +24059 # if (outputs == 0) break +24060 81 7/subop/compare %ecx 0/imm32 +24061 0f 84/jump-if-= break/disp32 +24062 # if (expected == 0) error +24063 81 7/subop/compare %edx 0/imm32 +24064 0f 84/jump-if-= break/disp32 +24065 $check-mu-call:check-output-type: +24066 # var v/eax: (addr v) = lookup(outputs->value) +24067 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +24068 # var t/ebx: (addr type-tree) = lookup(v->type) +24069 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +24070 89/<- %ebx 0/r32/eax +24071 # if (outputs->is-deref?) t = t->right # TODO: check that t->left is an addr +24072 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +24073 { +24074 74/jump-if-= break/disp8 +24075 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +24076 89/<- %ebx 0/r32/eax +24077 } +24078 # var v2/eax: (addr v) = lookup(expected->value) +24079 (lookup *edx *(edx+4)) # List-value List-value => eax +24080 # var t2/eax: (addr type-tree) = lookup(v2->type) +24081 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +24082 # if (t != t2) error +24083 (type-match? %eax %ebx *(ebp-4)) # => eax +24084 3d/compare-eax-and 0/imm32/false +24085 { +24086 0f 85/jump-if-!= break/disp32 +24087 (write-buffered *(ebp+0x14) "fn ") +24088 8b/-> *(ebp+0x10) 0/r32/eax +24089 (lookup *eax *(eax+4)) # Function-name Function-name => eax +24090 (write-buffered *(ebp+0x14) %eax) +24091 (write-buffered *(ebp+0x14) ": call ") +24092 (lookup *edi *(edi+4)) # Function-name Function-name => eax +24093 (write-buffered *(ebp+0x14) %eax) +24094 (write-buffered *(ebp+0x14) ": type for output '") +24095 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +24096 (lookup *eax *(eax+4)) # Var-name Var-name => eax +24097 (write-buffered *(ebp+0x14) %eax) +24098 (write-buffered *(ebp+0x14) "' is not right\n") +24099 (flush *(ebp+0x14)) +24100 (stop *(ebp+0x18) 1) +24101 } +24102 $check-mu-call:check-output-register: +24103 # var v/eax: (addr v) = lookup(outputs->value) +24104 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +24105 # var r/ebx: (addr array byte) = lookup(v->register) +24106 (lookup *(eax+18) *(eax+0x1c)) # Var-register Var-register => eax +24107 89/<- %ebx 0/r32/eax +24108 # if (r == 0) error +24109 3d/compare-eax-and 0/imm32 +24110 { +24111 0f 85/jump-if-!= break/disp32 +24112 (write-buffered *(ebp+0x14) "fn ") +24113 8b/-> *(ebp+0x10) 0/r32/eax +24114 (lookup *eax *(eax+4)) # Function-name Function-name => eax +24115 (write-buffered *(ebp+0x14) %eax) +24116 (write-buffered *(ebp+0x14) ": call ") +24117 (lookup *edi *(edi+4)) # Function-name Function-name => eax +24118 (write-buffered *(ebp+0x14) %eax) +24119 (write-buffered *(ebp+0x14) ": output '") +24120 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +24121 (lookup *eax *(eax+4)) # Var-name Var-name => eax +24122 (write-buffered *(ebp+0x14) %eax) +24123 (write-buffered *(ebp+0x14) "' is not in a register\n") +24124 (flush *(ebp+0x14)) +24125 (stop *(ebp+0x18) 1) +24126 } +24127 # var v2/eax: (addr v) = lookup(expected->value) +24128 (lookup *edx *(edx+4)) # Stmt-var-value Stmt-var-value => eax +24129 # var r2/eax: (addr array byte) = lookup(v2->register) +24130 (lookup *(eax+18) *(eax+0x1c)) # Var-register Var-register => eax +24131 # if (r != r2) error +24132 (string-equal? %eax %ebx) # => eax +24133 3d/compare-eax-and 0/imm32/false +24134 { +24135 0f 85/jump-if-!= break/disp32 +24136 (write-buffered *(ebp+0x14) "fn ") +24137 8b/-> *(ebp+0x10) 0/r32/eax +24138 (lookup *eax *(eax+4)) # Function-name Function-name => eax +24139 (write-buffered *(ebp+0x14) %eax) +24140 (write-buffered *(ebp+0x14) ": call ") +24141 (lookup *edi *(edi+4)) # Function-name Function-name => eax +24142 (write-buffered *(ebp+0x14) %eax) +24143 (write-buffered *(ebp+0x14) ": register for output '") +24144 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +24145 (lookup *eax *(eax+4)) # Var-name Var-name => eax +24146 (write-buffered *(ebp+0x14) %eax) +24147 (write-buffered *(ebp+0x14) "' is not right\n") +24148 (flush *(ebp+0x14)) +24149 (stop *(ebp+0x18) 1) +24150 } +24151 $check-mu-call:continue-to-next-output: +24152 # outputs = lookup(outputs->next) +24153 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +24154 89/<- %ecx 0/r32/eax +24155 # expected = lookup(expected->next) +24156 (lookup *(edx+8) *(edx+0xc)) # List-next List-next => eax +24157 89/<- %edx 0/r32/eax +24158 # +24159 e9/jump loop/disp32 +24160 } +24161 $check-mu-call:check-output-count: +24162 # if (outputs == expected) proceed +24163 39/compare %ecx 2/r32/edx +24164 { +24165 0f 84/jump-if-= break/disp32 +24166 # exactly one of the two is null +24167 # if (outputs == 0) error("too many outputs") +24168 { +24169 81 7/subop/compare %ecx 0/imm32 +24170 0f 84/jump-if-= break/disp32 +24171 (write-buffered *(ebp+0x14) "fn ") +24172 8b/-> *(ebp+0x10) 0/r32/eax +24173 (lookup *eax *(eax+4)) # Function-name Function-name => eax +24174 (write-buffered *(ebp+0x14) %eax) +24175 (write-buffered *(ebp+0x14) ": call ") +24176 (lookup *edi *(edi+4)) # Function-name Function-name => eax +24177 (write-buffered *(ebp+0x14) %eax) +24178 (write-buffered *(ebp+0x14) ": too many outputs\n") +24179 (flush *(ebp+0x14)) +24180 (stop *(ebp+0x18) 1) +24181 } +24182 # if (expected == 0) error("too few outputs") +24183 { +24184 81 7/subop/compare %edx 0/imm32 +24185 0f 84/jump-if-= break/disp32 +24186 (write-buffered *(ebp+0x14) "fn ") +24187 8b/-> *(ebp+0x10) 0/r32/eax +24188 (lookup *eax *(eax+4)) # Function-name Function-name => eax +24189 (write-buffered *(ebp+0x14) %eax) +24190 (write-buffered *(ebp+0x14) ": call ") +24191 (lookup *edi *(edi+4)) # Function-name Function-name => eax +24192 (write-buffered *(ebp+0x14) %eax) +24193 (write-buffered *(ebp+0x14) ": too few outputs\n") +24194 (flush *(ebp+0x14)) +24195 (stop *(ebp+0x18) 1) +24196 } +24197 } +24198 $check-mu-call:end: +24199 # . restore registers +24200 5f/pop-to-edi +24201 5e/pop-to-esi +24202 5b/pop-to-ebx +24203 5a/pop-to-edx +24204 59/pop-to-ecx +24205 58/pop-to-eax +24206 # . reclaim locals exclusively on the stack +24207 81 0/subop/add %esp 0x70/imm32 +24208 # . epilogue +24209 89/<- %esp 5/r32/ebp +24210 5d/pop-to-ebp +24211 c3/return +24212 +24213 # like type-equal? but takes literals type parameters into account +24214 type-match?: # def: (addr type-tree), call: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean +24215 # . prologue +24216 55/push-ebp +24217 89/<- %ebp 4/r32/esp +24218 # if (call is literal and def is numberlike) return true +24219 { +24220 $type-match?:check-literal-int: +24221 (is-simple-mu-type? *(ebp+0xc) 0) # literal => eax +24222 3d/compare-eax-and 0/imm32/false +24223 74/jump-if-= break/disp8 +24224 (is-mu-numberlike-output? *(ebp+8)) # => eax +24225 3d/compare-eax-and 0/imm32/false +24226 74/jump-if-= break/disp8 +24227 b8/copy-to-eax 1/imm32/true +24228 e9/jump $type-match?:end/disp32 +24229 } +24230 # if (call is literal-string and def is string) return true +24231 { +24232 $type-match?:check-literal-string: +24233 (is-simple-mu-type? *(ebp+0xc) 0x10) # literal-string => eax +24234 3d/compare-eax-and 0/imm32/false +24235 74/jump-if-= break/disp8 +24236 (is-mu-string-type? *(ebp+8)) # => eax +24237 3d/compare-eax-and 0/imm32/false +24238 74/jump-if-= break/disp8 +24239 b8/copy-to-eax 1/imm32/true +24240 e9/jump $type-match?:end/disp32 +24241 } +24242 $type-match?:baseline: +24243 # otherwise fall back +24244 (type-component-match? *(ebp+8) *(ebp+0xc) *(ebp+0x10)) # => eax +24245 $type-match?:end: +24246 # . epilogue +24247 89/<- %esp 5/r32/ebp +24248 5d/pop-to-ebp +24249 c3/return +24250 +24251 type-component-match?: # def: (addr type-tree), call: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean +24252 # . prologue +24253 55/push-ebp +24254 89/<- %ebp 4/r32/esp +24255 # . save registers +24256 51/push-ecx +24257 52/push-edx +24258 53/push-ebx +24259 # ecx = def +24260 8b/-> *(ebp+8) 1/r32/ecx +24261 # edx = call +24262 8b/-> *(ebp+0xc) 2/r32/edx +24263 $type-component-match?:compare-addr: +24264 # if (def == call) return true +24265 8b/-> %ecx 0/r32/eax # Var-type +24266 39/compare %edx 0/r32/eax # Var-type +24267 b8/copy-to-eax 1/imm32/true +24268 0f 84/jump-if-= $type-component-match?:end/disp32 +24269 # if (def == 0) return false +24270 b8/copy-to-eax 0/imm32/false +24271 81 7/subop/compare %ecx 0/imm32 # Type-tree-is-atom +24272 0f 84/jump-if-= $type-component-match?:end/disp32 +24273 # if (call == 0) return false +24274 81 7/subop/compare %edx 0/imm32 # Type-tree-is-atom +24275 0f 84/jump-if-= $type-component-match?:end/disp32 +24276 # if def is a type parameter, just check in type-parameters +24277 { +24278 $type-component-match?:check-type-parameter: +24279 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +24280 74/jump-if-= break/disp8 +24281 81 7/subop/compare *(ecx+4) 0xa/imm32/type-parameter # Type-tree-value +24282 75/jump-if-!= break/disp8 +24283 $type-component-match?:type-parameter: +24284 (type-parameter-match? *(ecx+8) *(ecx+0xc) %edx *(ebp+0x10)) # => eax +24285 e9/jump $type-component-match?:end/disp32 +24286 } +24287 # if def is a list containing just a type parameter, just check in type-parameters +24288 { +24289 $type-component-match?:check-list-type-parameter: +24290 # if def is a list.. +24291 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +24292 75/jump-if-!= break/disp8 +24293 # ..that's a singleton +24294 81 7/subop/compare *(ecx+0xc) 0/imm32 # Type-tree-left +24295 75/jump-if-!= break/disp8 +24296 # ..and whose head is a type parameter +24297 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24298 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +24299 74/jump-if-= break/disp8 +24300 81 7/subop/compare *(eax+4) 0xa/imm32/type-parameter # Type-tree-value +24301 75/jump-if-!= break/disp8 +24302 $type-component-match?:list-type-parameter: +24303 (type-parameter-match? *(eax+8) *(eax+0xc) %edx *(ebp+0x10)) # => eax +24304 e9/jump $type-component-match?:end/disp32 +24305 } +24306 $type-component-match?:compare-atom-state: +24307 # if (def->is-atom? != call->is-atom?) return false +24308 8b/-> *ecx 3/r32/ebx # Type-tree-is-atom +24309 39/compare *edx 3/r32/ebx # Type-tree-is-atom +24310 b8/copy-to-eax 0/imm32/false +24311 0f 85/jump-if-!= $type-component-match?:end/disp32 +24312 # if def->is-atom? return (def->value == call->value) +24313 { +24314 $type-component-match?:check-atom: +24315 81 7/subop/compare %ebx 0/imm32/false +24316 74/jump-if-= break/disp8 +24317 $type-component-match?:is-atom: +24318 8b/-> *(ecx+4) 0/r32/eax # Type-tree-value +24319 39/compare *(edx+4) 0/r32/eax # Type-tree-value +24320 0f 94/set-if-= %al +24321 81 4/subop/and %eax 0xff/imm32 +24322 e9/jump $type-component-match?:end/disp32 +24323 } +24324 $type-component-match?:check-left: +24325 # if (!type-component-match?(def->left, call->left)) return false +24326 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24327 89/<- %ebx 0/r32/eax +24328 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +24329 (type-component-match? %ebx %eax *(ebp+0x10)) # => eax +24330 3d/compare-eax-and 0/imm32/false +24331 74/jump-if-= $type-component-match?:end/disp8 +24332 $type-component-match?:check-right: +24333 # return type-component-match?(def->right, call->right) +24334 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +24335 89/<- %ebx 0/r32/eax +24336 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax +24337 (type-component-match? %ebx %eax *(ebp+0x10)) # => eax +24338 $type-component-match?:end: +24339 # . restore registers +24340 5b/pop-to-ebx +24341 5a/pop-to-edx +24342 59/pop-to-ecx +24343 # . epilogue +24344 89/<- %esp 5/r32/ebp +24345 5d/pop-to-ebp +24346 c3/return +24347 +24348 type-parameter-match?: # type-parameter-name: (handle array byte), type: (addr type-tree), type-parameters: (addr table (handle array byte) (addr type-tree)) -> result/eax: boolean +24349 # . prologue +24350 55/push-ebp +24351 89/<- %ebp 4/r32/esp +24352 # . save registers +24353 51/push-ecx +24354 # +24355 (get-or-insert-handle *(ebp+0x14) *(ebp+8) *(ebp+0xc) 0xc) # => eax +24356 # if parameter wasn't saved, save it +24357 { +24358 81 7/subop/compare *eax 0/imm32 +24359 75/jump-if-!= break/disp8 +24360 8b/-> *(ebp+0x10) 1/r32/ecx +24361 89/<- *eax 1/r32/ecx +24362 } +24363 # +24364 (type-equal? *(ebp+0x10) *eax) # => eax +24365 $type-parameter-match?:end: +24366 # . restore registers +24367 59/pop-to-ecx +24368 # . epilogue +24369 89/<- %esp 5/r32/ebp +24370 5d/pop-to-ebp +24371 c3/return +24372 +24373 size-of: # v: (addr var) -> result/eax: int +24374 # . prologue +24375 55/push-ebp +24376 89/<- %ebp 4/r32/esp +24377 # . save registers +24378 51/push-ecx +24379 # var t/ecx: (addr type-tree) = lookup(v->type) +24380 8b/-> *(ebp+8) 1/r32/ecx +24381 #? (write-buffered Stderr "size-of ") +24382 #? (write-int32-hex-buffered Stderr %ecx) +24383 #? (write-buffered Stderr Newline) +24384 #? (write-buffered Stderr "type allocid: ") +24385 #? (write-int32-hex-buffered Stderr *(ecx+8)) +24386 #? (write-buffered Stderr Newline) +24387 #? (flush Stderr) +24388 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +24389 89/<- %ecx 0/r32/eax +24390 # if is-mu-array?(t) return size-of-array(t) +24391 { +24392 (is-mu-array? %ecx) # => eax +24393 3d/compare-eax-and 0/imm32/false +24394 74/jump-if-= break/disp8 +24395 (size-of-array %ecx) # => eax +24396 eb/jump $size-of:end/disp8 +24397 } +24398 # if is-mu-stream?(t) return size-of-stream(t) +24399 { +24400 (is-mu-stream? %ecx) # => eax +24401 3d/compare-eax-and 0/imm32/false +24402 74/jump-if-= break/disp8 +24403 (size-of-stream %ecx) # => eax +24404 eb/jump $size-of:end/disp8 +24405 } +24406 # if (!t->is-atom?) t = lookup(t->left) +24407 { +24408 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +24409 75/jump-if-!= break/disp8 +24410 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24411 89/<- %ecx 0/r32/eax +24412 } +24413 # TODO: assert t->is-atom? +24414 (size-of-type-id *(ecx+4)) # Type-tree-value => eax +24415 $size-of:end: +24416 # . restore registers +24417 59/pop-to-ecx +24418 # . epilogue +24419 89/<- %esp 5/r32/ebp +24420 5d/pop-to-ebp +24421 c3/return +24422 +24423 size-of-deref: # v: (addr var) -> result/eax: int +24424 # . prologue +24425 55/push-ebp +24426 89/<- %ebp 4/r32/esp +24427 # . save registers +24428 51/push-ecx +24429 # var t/ecx: (addr type-tree) = lookup(v->type) +24430 8b/-> *(ebp+8) 1/r32/ecx +24431 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +24432 89/<- %ecx 0/r32/eax +24433 # TODO: assert(t is an addr) +24434 # t = lookup(t->right) +24435 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +24436 89/<- %ecx 0/r32/eax +24437 # if is-mu-array?(t) return size-of-array(t) +24438 { +24439 (is-mu-array? %ecx) # => eax +24440 3d/compare-eax-and 0/imm32/false +24441 74/jump-if-= break/disp8 +24442 (size-of-array %ecx) # => eax +24443 eb/jump $size-of-deref:end/disp8 +24444 } +24445 # if is-mu-stream?(t) return size-of-stream(t) +24446 { +24447 (is-mu-stream? %ecx) # => eax +24448 3d/compare-eax-and 0/imm32/false +24449 74/jump-if-= break/disp8 +24450 (size-of-stream %ecx) # => eax +24451 eb/jump $size-of-deref:end/disp8 +24452 } +24453 # if (!t->is-atom?) t = lookup(t->left) +24454 { +24455 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +24456 75/jump-if-!= break/disp8 +24457 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24458 89/<- %ecx 0/r32/eax +24459 } +24460 # TODO: assert t->is-atom? +24461 (size-of-type-id *(ecx+4)) # Type-tree-value => eax +24462 $size-of-deref:end: +24463 # . restore registers +24464 59/pop-to-ecx +24465 # . epilogue +24466 89/<- %esp 5/r32/ebp +24467 5d/pop-to-ebp +24468 c3/return +24469 +24470 is-mu-array?: # t: (addr type-tree) -> result/eax: boolean +24471 # . prologue +24472 55/push-ebp +24473 89/<- %ebp 4/r32/esp +24474 # . save registers +24475 51/push-ecx +24476 # ecx = t +24477 8b/-> *(ebp+8) 1/r32/ecx +24478 # if t->is-atom?, return false +24479 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +24480 75/jump-if-!= $is-mu-array?:return-false/disp8 +24481 # if !t->left->is-atom?, return false +24482 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24483 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +24484 74/jump-if-= $is-mu-array?:return-false/disp8 +24485 # return t->left->value == array +24486 81 7/subop/compare *(eax+4) 3/imm32/array-type-id # Type-tree-value +24487 0f 94/set-if-= %al +24488 81 4/subop/and %eax 0xff/imm32 +24489 eb/jump $is-mu-array?:end/disp8 +24490 $is-mu-array?:return-false: +24491 b8/copy-to-eax 0/imm32/false +24492 $is-mu-array?:end: +24493 # . restore registers +24494 59/pop-to-ecx +24495 # . epilogue +24496 89/<- %esp 5/r32/ebp +24497 5d/pop-to-ebp +24498 c3/return +24499 +24500 # size of a statically allocated array where the size is part of the type expression +24501 size-of-array: # a: (addr type-tree) -> result/eax: int +24502 # . prologue +24503 55/push-ebp +24504 89/<- %ebp 4/r32/esp +24505 # . save registers +24506 51/push-ecx +24507 52/push-edx +24508 # +24509 8b/-> *(ebp+8) 1/r32/ecx +24510 # TODO: assert that a->left is 'array' +24511 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +24512 89/<- %ecx 0/r32/eax +24513 # var elem-type/edx: type-id = a->right->left->value +24514 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24515 8b/-> *(eax+4) 2/r32/edx # Type-tree-value +24516 # TODO: assert that a->right->right->left->value == size +24517 # var array-size/ecx: int = a->right->right->left->value-size +24518 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +24519 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +24520 8b/-> *(eax+8) 1/r32/ecx # Type-tree-value-size +24521 # return 4 + array-size * size-of(elem-type) +24522 (size-of-type-id-as-array-element %edx) # => eax +24523 f7 4/subop/multiply-into-edx-eax %ecx +24524 05/add-to-eax 4/imm32 # for array size +24525 # TODO: check edx for overflow +24526 $size-of-array:end: +24527 # . restore registers +24528 5a/pop-to-edx +24529 59/pop-to-ecx +24530 # . epilogue +24531 89/<- %esp 5/r32/ebp +24532 5d/pop-to-ebp +24533 c3/return +24534 +24535 is-mu-stream?: # t: (addr type-tree) -> result/eax: boolean +24536 # . prologue +24537 55/push-ebp +24538 89/<- %ebp 4/r32/esp +24539 # . save registers +24540 51/push-ecx +24541 # ecx = t +24542 8b/-> *(ebp+8) 1/r32/ecx +24543 # if t->is-atom?, return false +24544 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +24545 75/jump-if-!= $is-mu-stream?:return-false/disp8 +24546 # if !t->left->is-atom?, return false +24547 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24548 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +24549 74/jump-if-= $is-mu-stream?:return-false/disp8 +24550 # return t->left->value == stream +24551 81 7/subop/compare *(eax+4) 0xb/imm32/stream-type-id # Type-tree-value +24552 0f 94/set-if-= %al +24553 81 4/subop/and %eax 0xff/imm32 +24554 eb/jump $is-mu-stream?:end/disp8 +24555 $is-mu-stream?:return-false: +24556 b8/copy-to-eax 0/imm32/false +24557 $is-mu-stream?:end: +24558 # . restore registers +24559 59/pop-to-ecx +24560 # . epilogue +24561 89/<- %esp 5/r32/ebp +24562 5d/pop-to-ebp +24563 c3/return +24564 +24565 # size of a statically allocated stream where the size is part of the type expression +24566 size-of-stream: # a: (addr type-tree) -> result/eax: int +24567 # . prologue +24568 55/push-ebp +24569 89/<- %ebp 4/r32/esp +24570 # +24571 (size-of-array *(ebp+8)) # assumes we ignore the actual type name 'array' in the type +24572 05/add-to-eax 8/imm32 # for read/write pointers +24573 $size-of-stream:end: +24574 # . epilogue +24575 89/<- %esp 5/r32/ebp +24576 5d/pop-to-ebp +24577 c3/return +24578 +24579 size-of-type-id: # t: type-id -> result/eax: int +24580 # . prologue +24581 55/push-ebp +24582 89/<- %ebp 4/r32/esp +24583 # . save registers +24584 51/push-ecx +24585 # var out/ecx: (handle typeinfo) +24586 68/push 0/imm32 +24587 68/push 0/imm32 +24588 89/<- %ecx 4/r32/esp +24589 # eax = t +24590 8b/-> *(ebp+8) 0/r32/eax +24591 # if t is a literal, return 0 +24592 3d/compare-eax-and 0/imm32 +24593 0f 84/jump-if-= $size-of-type-id:end/disp32 # eax changes type from type-id to int +24594 # if t is a byte, return 4 (because we don't really support non-multiples of 4) +24595 3d/compare-eax-and 8/imm32/byte +24596 { +24597 75/jump-if-!= break/disp8 +24598 b8/copy-to-eax 4/imm32 +24599 eb/jump $size-of-type-id:end/disp8 +24600 } +24601 # if t is a handle, return 8 +24602 3d/compare-eax-and 4/imm32/handle 24603 { -24604 $emit-cleanup-code-for-non-outputs:loop: -24605 # if (curr < min) break -24606 39/compare %esi 1/r32/ecx -24607 0f 82/jump-if-addr< break/disp32 -24608 # var v/ebx: (addr var) = lookup(*curr) -24609 (lookup *esi *(esi+4)) # => eax -24610 89/<- %ebx 0/r32/eax -24611 # if v is in a register -24612 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register -24613 { -24614 0f 84/jump-if-= break/disp32 -24615 { -24616 $emit-cleanup-code-for-non-outputs:check-for-previous-spill: -24617 8b/-> *(esi+8) 0/r32/eax # Live-var-register-spilled -24618 3d/compare-eax-and 0/imm32/false -24619 0f 84/jump-if-= break/disp32 -24620 $emit-cleanup-code-for-non-outputs:reclaim-var-in-register: -24621 # var reg/edi: (addr array name) = v->register -24622 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -24623 89/<- %edi 0/r32/eax -24624 # if reg is not in function outputs, emit a pop -24625 (reg-in-function-outputs? *(ebp+0x10) %edi) # => eax -24626 3d/compare-eax-and 0/imm32/false -24627 { -24628 75/jump-if-!= break/disp8 -24629 (emit-pop-register *(ebp+8) %edi) -24630 eb/jump $emit-cleanup-code-for-non-outputs:reclaim-var-in-register-done/disp8 -24631 } -24632 # otherwise just drop it from the stack -24633 (emit-indent *(ebp+8) *Curr-block-depth) -24634 (write-buffered *(ebp+8) "81 0/subop/add %esp 4/imm32\n") -24635 } -24636 $emit-cleanup-code-for-non-outputs:reclaim-var-in-register-done: -24637 eb/jump $emit-cleanup-code-for-non-outputs:continue/disp8 -24638 } -24639 # otherwise v is on the stack -24640 { -24641 75/jump-if-!= break/disp8 -24642 $emit-cleanup-code-for-non-outputs:var-on-stack: -24643 (size-of %ebx) # => eax -24644 # don't emit code for labels -24645 3d/compare-eax-and 0/imm32 -24646 74/jump-if-= break/disp8 -24647 $emit-cleanup-code-for-non-outputs:reclaim-var-on-stack: -24648 (emit-indent *(ebp+8) *Curr-block-depth) -24649 (write-buffered *(ebp+8) "81 0/subop/add %esp ") -24650 (write-int32-hex-buffered *(ebp+8) %eax) -24651 (write-buffered *(ebp+8) "/imm32\n") -24652 } -24653 $emit-cleanup-code-for-non-outputs:continue: -24654 # curr -= 12 -24655 81 5/subop/subtract %esi 0xc/imm32 -24656 e9/jump loop/disp32 -24657 } -24658 $emit-cleanup-code-for-non-outputs:end: -24659 # . restore registers -24660 5f/pop-to-edi -24661 5e/pop-to-esi -24662 5b/pop-to-ebx -24663 5a/pop-to-edx -24664 59/pop-to-ecx -24665 58/pop-to-eax -24666 # . epilogue -24667 89/<- %esp 5/r32/ebp -24668 5d/pop-to-ebp -24669 c3/return -24670 -24671 emit-push-register: # out: (addr buffered-file), reg: (addr array byte) -24672 # . prologue -24673 55/push-ebp -24674 89/<- %ebp 4/r32/esp -24675 # eax = reg -24676 8b/-> *(ebp+0xc) 0/r32/eax -24677 # var prefix/eax: byte = reg->data[0] -24678 8a/copy-byte *(eax+4) 0/r32/AL -24679 81 4/subop/and %eax 0xff/imm32 -24680 # if (prefix == 'x') push xmm register -24681 { -24682 3d/compare-eax-and 0x78/imm32/x -24683 0f 85/jump-if-!= break/disp32 -24684 # TODO validate register -24685 (emit-indent *(ebp+8) *Curr-block-depth) -24686 (write-buffered *(ebp+8) "81 5/subop/subtract %esp 4/imm32\n") -24687 (emit-indent *(ebp+8) *Curr-block-depth) -24688 (write-buffered *(ebp+8) "f3 0f 11/<- *esp ") -24689 # var prefix/eax: byte = reg->data[3] -24690 8b/-> *(ebp+0xc) 0/r32/eax -24691 8a/copy-byte *(eax+7) 0/r32/AL -24692 81 4/subop/and %eax 0xff/imm32 -24693 (write-byte-buffered *(ebp+8) %eax) -24694 (write-buffered *(ebp+8) "/x32\n") -24695 e9/jump $emit-push-register:end/disp32 -24696 } -24697 # otherwise push gp register -24698 (emit-indent *(ebp+8) *Curr-block-depth) -24699 (write-buffered *(ebp+8) "ff 6/subop/push %") -24700 (write-buffered *(ebp+8) *(ebp+0xc)) -24701 (write-buffered *(ebp+8) Newline) -24702 $emit-push-register:end: -24703 # . epilogue -24704 89/<- %esp 5/r32/ebp -24705 5d/pop-to-ebp -24706 c3/return -24707 -24708 emit-pop-register: # out: (addr buffered-file), reg: (addr array byte) -24709 # . prologue -24710 55/push-ebp -24711 89/<- %ebp 4/r32/esp -24712 # . save registers -24713 50/push-eax -24714 # eax = reg -24715 8b/-> *(ebp+0xc) 0/r32/eax -24716 # var prefix/eax: byte = reg->data[0] -24717 8a/copy-byte *(eax+4) 0/r32/AL -24718 81 4/subop/and %eax 0xff/imm32 -24719 # if (prefix == 'x') pop to xmm register -24720 { -24721 3d/compare-eax-and 0x78/imm32/x -24722 0f 85/jump-if-!= break/disp32 -24723 # TODO validate register -24724 (emit-indent *(ebp+8) *Curr-block-depth) -24725 (write-buffered *(ebp+8) "f3 0f 10/-> *esp ") -24726 # var prefix/eax: byte = reg->data[3] -24727 8b/-> *(ebp+0xc) 0/r32/eax -24728 8a/copy-byte *(eax+7) 0/r32/AL -24729 81 4/subop/and %eax 0xff/imm32 -24730 (write-byte-buffered *(ebp+8) %eax) -24731 (write-buffered *(ebp+8) "/x32\n") -24732 (emit-indent *(ebp+8) *Curr-block-depth) -24733 (write-buffered *(ebp+8) "81 0/subop/add %esp 4/imm32\n") -24734 e9/jump $emit-pop-register:end/disp32 -24735 } -24736 # otherwise pop to gp register -24737 (emit-indent *(ebp+8) *Curr-block-depth) -24738 (write-buffered *(ebp+8) "8f 0/subop/pop %") -24739 (write-buffered *(ebp+8) *(ebp+0xc)) -24740 (write-buffered *(ebp+8) Newline) -24741 $emit-pop-register:end: -24742 # . restore registers -24743 58/pop-to-eax -24744 # . epilogue -24745 89/<- %esp 5/r32/ebp -24746 5d/pop-to-ebp -24747 c3/return -24748 -24749 # emit clean-up code for 'vars' until a given label is encountered -24750 # doesn't actually modify 'vars' so we need traverse manually inside the stack -24751 emit-cleanup-code-until-target: # out: (addr buffered-file), vars: (addr stack live-var), until-block-label: (addr array byte) -24752 # . prologue -24753 55/push-ebp -24754 89/<- %ebp 4/r32/esp -24755 # . save registers -24756 50/push-eax -24757 51/push-ecx -24758 52/push-edx -24759 53/push-ebx -24760 # ecx = vars -24761 8b/-> *(ebp+0xc) 1/r32/ecx -24762 # var eax: int = vars->top -24763 8b/-> *ecx 0/r32/eax -24764 # var curr/edx: (addr handle var) = &vars->data[vars->top - 12] -24765 8d/copy-address *(ecx+eax-4) 2/r32/edx # vars + 8 + vars->top - 12/Live-var-size -24766 # var min/ecx: (addr handle var) = vars->data -24767 81 0/subop/add %ecx 8/imm32 -24768 { -24769 $emit-cleanup-code-until-target:loop: -24770 # if (curr < min) break -24771 39/compare %edx 1/r32/ecx -24772 0f 82/jump-if-addr< break/disp32 -24773 # var v/ebx: (handle var) = lookup(*curr) -24774 (lookup *edx *(edx+4)) # => eax -24775 89/<- %ebx 0/r32/eax -24776 # if (v->name == until-block-label) break -24777 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax -24778 (string-equal? %eax *(ebp+0x10)) # => eax -24779 3d/compare-eax-and 0/imm32/false -24780 0f 85/jump-if-!= break/disp32 -24781 # if v is in a register -24782 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register -24783 { -24784 0f 84/jump-if-= break/disp32 -24785 { -24786 $emit-cleanup-code-until-target:check-for-previous-spill: -24787 8b/-> *(edx+8) 0/r32/eax # Live-var-register-spilled -24788 3d/compare-eax-and 0/imm32/false -24789 74/jump-if-= break/disp8 -24790 $emit-cleanup-code-until-target:reclaim-var-in-register: -24791 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -24792 (emit-pop-register *(ebp+8) %eax) -24793 } -24794 eb/jump $emit-cleanup-code-until-target:continue/disp8 -24795 } -24796 # otherwise v is on the stack -24797 { -24798 75/jump-if-!= break/disp8 -24799 $emit-cleanup-code-until-target:reclaim-var-on-stack: -24800 (size-of %ebx) # => eax -24801 # don't emit code for labels -24802 3d/compare-eax-and 0/imm32 -24803 74/jump-if-= break/disp8 -24804 # -24805 (emit-indent *(ebp+8) *Curr-block-depth) -24806 (write-buffered *(ebp+8) "81 0/subop/add %esp ") -24807 (write-int32-hex-buffered *(ebp+8) %eax) -24808 (write-buffered *(ebp+8) "/imm32\n") -24809 } -24810 $emit-cleanup-code-until-target:continue: -24811 # curr -= 12 -24812 81 5/subop/subtract %edx 0xc/imm32 -24813 e9/jump loop/disp32 -24814 } -24815 $emit-cleanup-code-until-target:end: -24816 # . restore registers -24817 5b/pop-to-ebx -24818 5a/pop-to-edx -24819 59/pop-to-ecx -24820 58/pop-to-eax -24821 # . epilogue -24822 89/<- %esp 5/r32/ebp -24823 5d/pop-to-ebp -24824 c3/return -24825 -24826 # update Curr-local-stack-offset assuming vars until some block depth are popped -24827 # doesn't actually modify 'vars', so we need traverse manually inside the stack -24828 clean-up-stack-offset-state: # vars: (addr stack live-var), until-block-depth: int -24829 # . prologue -24830 55/push-ebp -24831 89/<- %ebp 4/r32/esp -24832 # . save registers -24833 50/push-eax -24834 51/push-ecx -24835 52/push-edx -24836 53/push-ebx -24837 56/push-esi -24838 # ecx = vars -24839 8b/-> *(ebp+8) 1/r32/ecx -24840 # var esi: int = vars->top -24841 8b/-> *ecx 6/r32/esi -24842 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] -24843 8d/copy-address *(ecx+esi-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size -24844 # var min/ecx: (addr handle var) = vars->data -24845 81 0/subop/add %ecx 8/imm32 -24846 # edx = until-block-depth -24847 8b/-> *(ebp+0xc) 2/r32/edx -24848 { -24849 $clean-up-stack-offset-state:loop: -24850 # if (curr < min) break -24851 39/compare %esi 1/r32/ecx -24852 0f 82/jump-if-addr< break/disp32 -24853 # var v/ebx: (addr var) = lookup(*curr) -24854 (lookup *esi *(esi+4)) # => eax -24855 89/<- %ebx 0/r32/eax -24856 # if (v->block-depth < until-block-depth) break -24857 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth -24858 0f 8c/jump-if-< break/disp32 -24859 # if v is in a register -24860 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register -24861 { -24862 0f 84/jump-if-= break/disp32 -24863 { -24864 $clean-up-stack-offset-state:check-for-previous-spill: -24865 8b/-> *(esi+8) 0/r32/eax # Live-var-register-spilled -24866 3d/compare-eax-and 0/imm32/false -24867 74/jump-if-= break/disp8 -24868 $clean-up-stack-offset-state:reclaim-var-in-register: -24869 81 0/subop/add *Curr-local-stack-offset 4/imm32 -24870 } -24871 eb/jump $clean-up-stack-offset-state:continue/disp8 -24872 } -24873 # otherwise v is on the stack -24874 { -24875 75/jump-if-!= break/disp8 -24876 $clean-up-stack-offset-state:var-on-stack: -24877 (size-of %ebx) # => eax -24878 01/add-to *Curr-local-stack-offset 0/r32/eax -24879 } -24880 $clean-up-stack-offset-state:continue: -24881 # curr -= 12 -24882 81 5/subop/subtract %esi 0xc/imm32 -24883 e9/jump loop/disp32 -24884 } -24885 $clean-up-stack-offset-state:end: -24886 # . restore registers -24887 5e/pop-to-esi -24888 5b/pop-to-ebx -24889 5a/pop-to-edx -24890 59/pop-to-ecx -24891 58/pop-to-eax -24892 # . epilogue -24893 89/<- %esp 5/r32/ebp -24894 5d/pop-to-ebp -24895 c3/return -24896 -24897 # Return true if there isn't a variable in 'vars' with the same block-depth -24898 # and register as 'v'. -24899 # 'v' is guaranteed not to be within 'vars'. -24900 not-yet-spilled-this-block?: # v: (addr var), vars: (addr stack live-var) -> result/eax: boolean -24901 # . prologue -24902 55/push-ebp -24903 89/<- %ebp 4/r32/esp -24904 # . save registers -24905 51/push-ecx -24906 52/push-edx -24907 53/push-ebx -24908 56/push-esi -24909 57/push-edi -24910 # ecx = vars -24911 8b/-> *(ebp+0xc) 1/r32/ecx -24912 # var eax: int = vars->top -24913 8b/-> *ecx 0/r32/eax -24914 # var curr/edx: (addr handle var) = &vars->data[vars->top - 12] -24915 8d/copy-address *(ecx+eax-4) 2/r32/edx # vars + 8 + vars->top - 12/Live-var-size -24916 # var min/ecx: (addr handle var) = vars->data -24917 8d/copy-address *(ecx+8) 1/r32/ecx -24918 # var depth/ebx: int = v->block-depth -24919 8b/-> *(ebp+8) 3/r32/ebx -24920 8b/-> *(ebx+0x10) 3/r32/ebx # Var-block-depth -24921 # var needle/esi: (addr array byte) = v->register -24922 8b/-> *(ebp+8) 6/r32/esi -24923 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -24924 89/<- %esi 0/r32/eax -24925 { -24926 $not-yet-spilled-this-block?:loop: -24927 # if (curr < min) break -24928 39/compare %edx 1/r32/ecx -24929 0f 82/jump-if-addr< break/disp32 -24930 # var cand/edi: (addr var) = lookup(*curr) -24931 (lookup *edx *(edx+4)) # => eax -24932 89/<- %edi 0/r32/eax -24933 # if (cand->block-depth < depth) break -24934 39/compare *(edi+0x10) 3/r32/ebx # Var-block-depth -24935 0f 8c/jump-if-< break/disp32 -24936 # var cand-reg/edi: (array array byte) = cand->reg -24937 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax -24938 89/<- %edi 0/r32/eax -24939 # if (cand-reg == null) continue -24940 { -24941 $not-yet-spilled-this-block?:check-reg: -24942 81 7/subop/compare %edi 0/imm32 -24943 0f 84/jump-if-= break/disp32 -24944 # if (cand-reg == needle) return true -24945 (string-equal? %esi %edi) # => eax -24946 3d/compare-eax-and 0/imm32/false -24947 74/jump-if-= break/disp8 -24948 $not-yet-spilled-this-block?:return-false: -24949 b8/copy-to-eax 0/imm32/false -24950 eb/jump $not-yet-spilled-this-block?:end/disp8 -24951 } -24952 $not-yet-spilled-this-block?:continue: -24953 # curr -= 12 -24954 81 5/subop/subtract %edx 0xc/imm32 -24955 e9/jump loop/disp32 -24956 } -24957 $not-yet-spilled-this-block?:return-true: -24958 # return true -24959 b8/copy-to-eax 1/imm32/true -24960 $not-yet-spilled-this-block?:end: -24961 # . restore registers -24962 5f/pop-to-edi -24963 5e/pop-to-esi -24964 5b/pop-to-ebx -24965 5a/pop-to-edx -24966 59/pop-to-ecx -24967 # . epilogue -24968 89/<- %esp 5/r32/ebp -24969 5d/pop-to-ebp -24970 c3/return -24971 -24972 # could the register of 'v' ever be written to by one of the vars in fn-outputs? -24973 will-not-write-some-register?: # v: (addr var), stmts: (addr list stmt), fn: (addr function) -> result/eax: boolean -24974 # . prologue -24975 55/push-ebp -24976 89/<- %ebp 4/r32/esp -24977 # eax = v -24978 8b/-> *(ebp+8) 0/r32/eax -24979 # var reg/eax: (addr array byte) = lookup(v->register) -24980 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -24981 # var target/eax: (addr var) = find-register(fn-outputs, reg) -24982 (find-register *(ebp+0x10) %eax) # => eax -24983 # if (target == 0) return true -24984 { -24985 3d/compare-eax-and 0/imm32 -24986 75/jump-if-!= break/disp8 -24987 b8/copy-to-eax 1/imm32/true -24988 eb/jump $will-not-write-some-register?:end/disp8 -24989 } -24990 # return !assigns-in-stmts?(stmts, target) -24991 (assigns-in-stmts? *(ebp+0xc) %eax) # => eax -24992 3d/compare-eax-and 0/imm32/false -24993 # assume: true = 1, so no need to mask with 0x000000ff -24994 0f 94/set-if-= %al -24995 $will-not-write-some-register?:end: -24996 # . epilogue -24997 89/<- %esp 5/r32/ebp -24998 5d/pop-to-ebp -24999 c3/return -25000 -25001 # return fn output with matching register -25002 # always returns false if 'reg' is null -25003 find-register: # fn: (addr function), reg: (addr array byte) -> result/eax: (addr var) -25004 # . prologue -25005 55/push-ebp -25006 89/<- %ebp 4/r32/esp -25007 # . save registers -25008 51/push-ecx -25009 # var curr/ecx: (addr list var) = lookup(fn->outputs) -25010 8b/-> *(ebp+8) 1/r32/ecx -25011 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax -25012 89/<- %ecx 0/r32/eax -25013 { -25014 $find-register:loop: -25015 # if (curr == 0) break -25016 81 7/subop/compare %ecx 0/imm32 -25017 74/jump-if-= break/disp8 -25018 # eax = curr->value->register -25019 (lookup *ecx *(ecx+4)) # List-value List-value => eax -25020 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -25021 # if (eax == reg) return curr->value -25022 $find-register:compare: -25023 (string-equal? *(ebp+0xc) %eax) # => eax -25024 { -25025 3d/compare-eax-and 0/imm32/false -25026 74/jump-if-= break/disp8 -25027 $find-register:found: -25028 (lookup *ecx *(ecx+4)) # List-value List-value => eax -25029 eb/jump $find-register:end/disp8 -25030 } -25031 # curr = lookup(curr->next) -25032 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -25033 89/<- %ecx 0/r32/eax -25034 # -25035 eb/jump loop/disp8 -25036 } -25037 $find-register:end: -25038 # . restore registers -25039 59/pop-to-ecx -25040 # . epilogue -25041 89/<- %esp 5/r32/ebp -25042 5d/pop-to-ebp -25043 c3/return -25044 -25045 assigns-in-stmts?: # stmts: (addr list stmt), v: (addr var) -> result/eax: boolean -25046 # . prologue -25047 55/push-ebp -25048 89/<- %ebp 4/r32/esp -25049 # . save registers -25050 51/push-ecx -25051 # var curr/ecx: (addr list stmt) = stmts -25052 8b/-> *(ebp+8) 1/r32/ecx -25053 { -25054 # if (curr == 0) break -25055 81 7/subop/compare %ecx 0/imm32 -25056 74/jump-if-= break/disp8 -25057 # if assigns-in-stmt?(curr->value, v) return true -25058 (lookup *ecx *(ecx+4)) # List-value List-value => eax -25059 (assigns-in-stmt? %eax *(ebp+0xc)) # => eax -25060 3d/compare-eax-and 0/imm32/false -25061 75/jump-if-!= break/disp8 -25062 # curr = lookup(curr->next) -25063 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -25064 89/<- %ecx 0/r32/eax -25065 # -25066 eb/jump loop/disp8 -25067 } -25068 $assigns-in-stmts?:end: -25069 # . restore registers -25070 59/pop-to-ecx -25071 # . epilogue -25072 89/<- %esp 5/r32/ebp -25073 5d/pop-to-ebp -25074 c3/return -25075 -25076 assigns-in-stmt?: # stmt: (addr stmt), v: (addr var) -> result/eax: boolean -25077 # . prologue -25078 55/push-ebp -25079 89/<- %ebp 4/r32/esp -25080 # . save registers -25081 51/push-ecx -25082 # ecx = stmt -25083 8b/-> *(ebp+8) 1/r32/ecx -25084 # if stmt is a stmt1, return assigns-in-stmt-vars?(stmt->outputs, v) -25085 { -25086 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag -25087 75/jump-if-!= break/disp8 -25088 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -25089 (assigns-in-stmt-vars? %eax *(ebp+0xc)) # => eax -25090 eb/jump $assigns-in-stmt?:end/disp8 -25091 } -25092 # if stmt is a block, return assigns-in-stmts?(stmt->stmts, v) -25093 { -25094 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag -25095 75/jump-if-!= break/disp8 -25096 (lookup *(ecx+4) *(ecx+8)) # Block-stmts Block-stmts => eax -25097 (assigns-in-stmts? %eax *(ebp+0xc)) # => eax -25098 eb/jump $assigns-in-stmt?:end/disp8 -25099 } -25100 # otherwise return false -25101 b8/copy 0/imm32/false -25102 $assigns-in-stmt?:end: -25103 # . restore registers -25104 59/pop-to-ecx -25105 # . epilogue -25106 89/<- %esp 5/r32/ebp -25107 5d/pop-to-ebp -25108 c3/return -25109 -25110 assigns-in-stmt-vars?: # stmt-var: (addr stmt-var), v: (addr var) -> result/eax: boolean -25111 # . prologue -25112 55/push-ebp -25113 89/<- %ebp 4/r32/esp -25114 # . save registers -25115 51/push-ecx -25116 # var curr/ecx: (addr stmt-var) = stmt-var -25117 8b/-> *(ebp+8) 1/r32/ecx -25118 { -25119 # if (curr == 0) break -25120 81 7/subop/compare %ecx 0/imm32 -25121 74/jump-if-= break/disp8 -25122 # eax = lookup(curr->value) -25123 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -25124 # if (eax == v && curr->is-deref? == false) return true -25125 { -25126 39/compare *(ebp+0xc) 0/r32/eax -25127 75/jump-if-!= break/disp8 -25128 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -25129 75/jump-if-!= break/disp8 -25130 b8/copy-to-eax 1/imm32/true -25131 eb/jump $assigns-in-stmt-vars?:end/disp8 -25132 } -25133 # curr = lookup(curr->next) -25134 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -25135 89/<- %ecx 0/r32/eax -25136 # -25137 eb/jump loop/disp8 -25138 } -25139 $assigns-in-stmt-vars?:end: -25140 # . restore registers -25141 59/pop-to-ecx -25142 # . epilogue -25143 89/<- %esp 5/r32/ebp -25144 5d/pop-to-ebp -25145 c3/return -25146 -25147 # is there a var before 'v' with the same block-depth and register on the 'vars' stack? -25148 # v is guaranteed to be within vars -25149 # 'start' is provided as an optimization, a pointer within vars -25150 # *start == v -25151 same-register-spilled-before?: # v: (addr var), vars: (addr stack (handle var)), start: (addr var) -> result/eax: boolean -25152 # . prologue -25153 55/push-ebp -25154 89/<- %ebp 4/r32/esp -25155 # . save registers -25156 51/push-ecx -25157 52/push-edx -25158 53/push-ebx -25159 56/push-esi -25160 57/push-edi -25161 # ecx = v -25162 8b/-> *(ebp+8) 1/r32/ecx -25163 # var reg/edx: (addr array byte) = lookup(v->register) -25164 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax -25165 89/<- %edx 0/r32/eax -25166 # var depth/ebx: int = v->block-depth -25167 8b/-> *(ecx+0x10) 3/r32/ebx # Var-block-depth -25168 # var min/ecx: (addr handle var) = vars->data -25169 8b/-> *(ebp+0xc) 1/r32/ecx -25170 81 0/subop/add %ecx 8/imm32 -25171 # TODO: check that start >= min and start < &vars->data[top] -25172 # TODO: check that *start == v -25173 # var curr/esi: (addr handle var) = start -25174 8b/-> *(ebp+0x10) 6/r32/esi -25175 # curr -= 8 -25176 81 5/subop/subtract %esi 8/imm32 -25177 { -25178 $same-register-spilled-before?:loop: -25179 # if (curr < min) break -25180 39/compare %esi 1/r32/ecx -25181 0f 82/jump-if-addr< break/disp32 -25182 # var x/eax: (addr var) = lookup(*curr) -25183 (lookup *esi *(esi+4)) # => eax -25184 # if (x->block-depth < depth) break -25185 39/compare *(eax+0x10) 3/r32/ebx # Var-block-depth -25186 0f 8c/jump-if-< break/disp32 -25187 # if (x->register == 0) continue -25188 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register -25189 74/jump-if-= $same-register-spilled-before?:continue/disp8 -25190 # if (x->register == reg) return true -25191 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -25192 (string-equal? %eax %edx) # => eax -25193 3d/compare-eax-and 0/imm32/false -25194 b8/copy-to-eax 1/imm32/true -25195 75/jump-if-!= $same-register-spilled-before?:end/disp8 -25196 $same-register-spilled-before?:continue: -25197 # curr -= 8 -25198 81 5/subop/subtract %esi 8/imm32 -25199 e9/jump loop/disp32 -25200 } -25201 $same-register-spilled-before?:false: -25202 b8/copy-to-eax 0/imm32/false -25203 $same-register-spilled-before?:end: -25204 # . restore registers -25205 5f/pop-to-edi -25206 5e/pop-to-esi -25207 5b/pop-to-ebx -25208 5a/pop-to-edx -25209 59/pop-to-ecx -25210 # . epilogue -25211 89/<- %esp 5/r32/ebp -25212 5d/pop-to-ebp -25213 c3/return -25214 -25215 # clean up global state for 'vars' until some block depth (inclusive) -25216 clean-up-blocks: # vars: (addr stack live-var), until-block-depth: int, fn: (addr function) -25217 # . prologue -25218 55/push-ebp -25219 89/<- %ebp 4/r32/esp -25220 # . save registers -25221 50/push-eax -25222 51/push-ecx -25223 56/push-esi -25224 # esi = vars -25225 8b/-> *(ebp+8) 6/r32/esi -25226 # ecx = until-block-depth -25227 8b/-> *(ebp+0xc) 1/r32/ecx -25228 { -25229 $clean-up-blocks:reclaim-loop: -25230 # if (vars->top <= 0) break -25231 8b/-> *esi 0/r32/eax # Stack-top -25232 3d/compare-eax-and 0/imm32 -25233 0f 8e/jump-if-<= break/disp32 -25234 # var v/eax: (addr var) = lookup(vars[vars->top-12]) -25235 (lookup *(esi+eax-4) *(esi+eax)) # vars + 8 + vars->top - 12 => eax -25236 # if (v->block-depth < until-block-depth) break -25237 39/compare *(eax+0x10) 1/r32/ecx # Var-block-depth -25238 0f 8c/jump-if-< break/disp32 -25239 (pop %esi) # => eax -25240 (pop %esi) # => eax -25241 (pop %esi) # => eax -25242 e9/jump loop/disp32 -25243 } -25244 $clean-up-blocks:end: -25245 # . restore registers -25246 5e/pop-to-esi -25247 59/pop-to-ecx -25248 58/pop-to-eax -25249 # . epilogue -25250 89/<- %esp 5/r32/ebp -25251 5d/pop-to-ebp -25252 c3/return -25253 -25254 reg-in-function-outputs?: # fn: (addr function), target: (addr array byte) -> result/eax: boolean -25255 # . prologue -25256 55/push-ebp -25257 89/<- %ebp 4/r32/esp -25258 # . save registers -25259 51/push-ecx -25260 # var curr/ecx: (addr list var) = lookup(fn->outputs) -25261 8b/-> *(ebp+8) 0/r32/eax -25262 (lookup *(eax+0x10) *(eax+0x14)) # Function-outputs Function-outputs => eax -25263 89/<- %ecx 0/r32/eax -25264 # while curr != null -25265 { -25266 81 7/subop/compare %ecx 0/imm32 -25267 74/jump-if-= break/disp8 -25268 # var v/eax: (addr var) = lookup(curr->value) -25269 (lookup *ecx *(ecx+4)) # List-value List-value => eax -25270 # var reg/eax: (addr array byte) = lookup(v->register) -25271 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -25272 # if (reg == target) return true -25273 (string-equal? %eax *(ebp+0xc)) # => eax -25274 3d/compare-eax-and 0/imm32/false -25275 75/jump-if-!= $reg-in-function-outputs?:end/disp8 -25276 # curr = curr->next -25277 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax -25278 89/<- %ecx 0/r32/eax -25279 # -25280 eb/jump loop/disp8 -25281 } -25282 # return false -25283 b8/copy-to-eax 0/imm32 -25284 $reg-in-function-outputs?:end: -25285 # . restore registers -25286 59/pop-to-ecx -25287 # . epilogue -25288 89/<- %esp 5/r32/ebp -25289 5d/pop-to-ebp -25290 c3/return -25291 -25292 emit-subx-var-def: # out: (addr buffered-file), stmt: (addr stmt) -25293 # . prologue -25294 55/push-ebp -25295 89/<- %ebp 4/r32/esp -25296 # . save registers -25297 50/push-eax -25298 51/push-ecx -25299 52/push-edx -25300 # eax = stmt -25301 8b/-> *(ebp+0xc) 0/r32/eax -25302 # var v/ecx: (addr var) -25303 (lookup *(eax+4) *(eax+8)) # Vardef-var Vardef-var => eax -25304 89/<- %ecx 0/r32/eax -25305 # v->block-depth = *Curr-block-depth -25306 8b/-> *Curr-block-depth 0/r32/eax -25307 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth -25308 # var n/edx: int = size-of(stmt->var) -25309 (size-of %ecx) # => eax -25310 89/<- %edx 0/r32/eax -25311 # *Curr-local-stack-offset -= n -25312 29/subtract-from *Curr-local-stack-offset 2/r32/edx -25313 # v->offset = *Curr-local-stack-offset -25314 8b/-> *Curr-local-stack-offset 0/r32/eax -25315 89/<- *(ecx+0x14) 0/r32/eax # Var-offset -25316 # if v is an array, do something special to initialize it -25317 { -25318 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -25319 (is-mu-array? %eax) # => eax -25320 3d/compare-eax-and 0/imm32/false -25321 0f 84/jump-if-= break/disp32 -25322 # var array-size-without-size/edx: int = n-4 -25323 81 5/subop/subtract %edx 4/imm32 -25324 # -25325 (emit-array-data-initialization *(ebp+8) %edx) -25326 e9/jump $emit-subx-var-def:end/disp32 -25327 } -25328 # another special-case for initializing streams -25329 # a stream is an array with 2 extra pointers -25330 { -25331 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax -25332 (is-mu-stream? %eax) # => eax -25333 3d/compare-eax-and 0/imm32/false -25334 0f 84/jump-if-= break/disp32 -25335 # var array-size-without-size/edx: int = n-12 -25336 81 5/subop/subtract %edx 0xc/imm32 -25337 (emit-array-data-initialization *(ebp+8) %edx) -25338 # emit read and write pointers -25339 (emit-indent *(ebp+8) *Curr-block-depth) -25340 (write-buffered *(ebp+8) "68/push 0/imm32\n") -25341 (emit-indent *(ebp+8) *Curr-block-depth) -25342 (write-buffered *(ebp+8) "68/push 0/imm32\n") -25343 # -25344 eb/jump $emit-subx-var-def:end/disp8 -25345 } -25346 # while n > 0 -25347 { -25348 81 7/subop/compare %edx 0/imm32 -25349 7e/jump-if-<= break/disp8 -25350 (emit-indent *(ebp+8) *Curr-block-depth) -25351 (write-buffered *(ebp+8) "68/push 0/imm32\n") -25352 # n -= 4 -25353 81 5/subop/subtract %edx 4/imm32 -25354 # -25355 eb/jump loop/disp8 -25356 } -25357 $emit-subx-var-def:end: -25358 # . restore registers -25359 5a/pop-to-edx -25360 59/pop-to-ecx -25361 58/pop-to-eax -25362 # . epilogue -25363 89/<- %esp 5/r32/ebp -25364 5d/pop-to-ebp -25365 c3/return -25366 -25367 emit-array-data-initialization: # out: (addr buffered-file), n: int -25368 # . prologue -25369 55/push-ebp -25370 89/<- %ebp 4/r32/esp -25371 # -25372 (emit-indent *(ebp+8) *Curr-block-depth) -25373 (write-buffered *(ebp+8) "(push-n-zero-bytes ") -25374 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc)) -25375 (write-buffered *(ebp+8) ")\n") -25376 (emit-indent *(ebp+8) *Curr-block-depth) -25377 (write-buffered *(ebp+8) "68/push ") -25378 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc)) -25379 (write-buffered *(ebp+8) "/imm32\n") -25380 $emit-array-data-initialization:end: -25381 # . epilogue -25382 89/<- %esp 5/r32/ebp -25383 5d/pop-to-ebp -25384 c3/return -25385 -25386 emit-subx-stmt: # out: (addr buffered-file), stmt: (addr stmt), primitives: (addr primitive), err: (addr buffered-file), ed: (addr exit-descriptor) -25387 # . prologue -25388 55/push-ebp -25389 89/<- %ebp 4/r32/esp -25390 # . save registers -25391 50/push-eax -25392 51/push-ecx -25393 # - some special-case primitives that don't actually use the 'primitives' data structure -25394 # var op/ecx: (addr array byte) = lookup(stmt->operation) -25395 8b/-> *(ebp+0xc) 1/r32/ecx -25396 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -25397 89/<- %ecx 0/r32/eax -25398 # array size -25399 { -25400 # if (!string-equal?(stmt->operation, "length")) break -25401 (string-equal? %ecx "length") # => eax -25402 3d/compare-eax-and 0/imm32 -25403 0f 84/jump-if-= break/disp32 -25404 (translate-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -25405 e9/jump $emit-subx-stmt:end/disp32 -25406 } -25407 # index into array -25408 { -25409 # if (!string-equal?(stmt->operation, "index")) break -25410 (string-equal? %ecx "index") # => eax -25411 3d/compare-eax-and 0/imm32 -25412 0f 84/jump-if-= break/disp32 -25413 (translate-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -25414 e9/jump $emit-subx-stmt:end/disp32 -25415 } -25416 # compute-offset for index into array -25417 { -25418 # if (!string-equal?(stmt->operation, "compute-offset")) break -25419 (string-equal? %ecx "compute-offset") # => eax -25420 3d/compare-eax-and 0/imm32 -25421 0f 84/jump-if-= break/disp32 -25422 (translate-mu-compute-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -25423 e9/jump $emit-subx-stmt:end/disp32 -25424 } -25425 # get field from record -25426 { -25427 # if (!string-equal?(stmt->operation, "get")) break -25428 (string-equal? %ecx "get") # => eax -25429 3d/compare-eax-and 0/imm32 -25430 0f 84/jump-if-= break/disp32 -25431 (translate-mu-get-stmt *(ebp+8) *(ebp+0xc)) -25432 e9/jump $emit-subx-stmt:end/disp32 -25433 } -25434 # allocate scalar -25435 { -25436 # if (!string-equal?(stmt->operation, "allocate")) break -25437 (string-equal? %ecx "allocate") # => eax -25438 3d/compare-eax-and 0/imm32 -25439 0f 84/jump-if-= break/disp32 -25440 (translate-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -25441 e9/jump $emit-subx-stmt:end/disp32 -25442 } -25443 # copy-object -25444 { -25445 # if (!string-equal?(stmt->operation, "copy-object")) break -25446 (string-equal? %ecx "copy-object") # => eax -25447 3d/compare-eax-and 0/imm32 -25448 0f 84/jump-if-= break/disp32 -25449 (translate-mu-copy-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -25450 e9/jump $emit-subx-stmt:end/disp32 -25451 } -25452 # allocate array -25453 { -25454 # if (!string-equal?(stmt->operation, "populate")) break -25455 (string-equal? %ecx "populate") # => eax -25456 3d/compare-eax-and 0/imm32 -25457 0f 84/jump-if-= break/disp32 -25458 (translate-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -25459 e9/jump $emit-subx-stmt:end/disp32 -25460 } -25461 # allocate stream -25462 { -25463 # if (!string-equal?(stmt->operation, "populate-stream")) break -25464 (string-equal? %ecx "populate-stream") # => eax -25465 3d/compare-eax-and 0/imm32 -25466 0f 84/jump-if-= break/disp32 -25467 (translate-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -25468 e9/jump $emit-subx-stmt:end/disp32 -25469 } -25470 # read from stream -25471 { -25472 # if (!string-equal?(stmt->operation, "read-from-stream")) break -25473 (string-equal? %ecx "read-from-stream") # => eax -25474 3d/compare-eax-and 0/imm32 -25475 0f 84/jump-if-= break/disp32 -25476 (translate-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -25477 e9/jump $emit-subx-stmt:end/disp32 -25478 } -25479 # write to stream -25480 { -25481 # if (!string-equal?(stmt->operation, "write-to-stream")) break -25482 (string-equal? %ecx "write-to-stream") # => eax -25483 3d/compare-eax-and 0/imm32 -25484 0f 84/jump-if-= break/disp32 -25485 (translate-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) -25486 e9/jump $emit-subx-stmt:end/disp32 -25487 } -25488 # - if stmt matches a primitive, emit it -25489 { -25490 $emit-subx-stmt:check-for-primitive: -25491 # var curr/eax: (addr primitive) -25492 (find-matching-primitive *(ebp+0x10) *(ebp+0xc)) # primitives, stmt => eax -25493 3d/compare-eax-and 0/imm32 -25494 74/jump-if-= break/disp8 -25495 $emit-subx-stmt:primitive: -25496 (emit-subx-primitive *(ebp+8) *(ebp+0xc) %eax) # out, stmt, curr -25497 e9/jump $emit-subx-stmt:end/disp32 -25498 } -25499 # - otherwise emit a call -25500 # TODO: type-checking -25501 $emit-subx-stmt:call: -25502 (emit-call *(ebp+8) *(ebp+0xc)) -25503 $emit-subx-stmt:end: -25504 # . restore registers -25505 59/pop-to-ecx -25506 58/pop-to-eax -25507 # . epilogue -25508 89/<- %esp 5/r32/ebp -25509 5d/pop-to-ebp -25510 c3/return -25511 -25512 translate-mu-length-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -25513 # . prologue -25514 55/push-ebp -25515 89/<- %ebp 4/r32/esp -25516 # . save registers -25517 50/push-eax -25518 51/push-ecx -25519 52/push-edx -25520 53/push-ebx -25521 56/push-esi -25522 # esi = stmt -25523 8b/-> *(ebp+0xc) 6/r32/esi -25524 # var base/ebx: (addr var) = stmt->inouts[0]->value -25525 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -25526 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -25527 89/<- %ebx 0/r32/eax -25528 # var elemsize/ecx: int = array-element-size(base) -25529 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax -25530 89/<- %ecx 0/r32/eax -25531 # var outreg/edx: (addr array byte) = stmt->outputs[0]->value->register -25532 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax -25533 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -25534 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -25535 89/<- %edx 0/r32/eax -25536 # if elemsize == 1 -25537 { -25538 81 7/subop/compare %ecx 1/imm32 -25539 75/jump-if-!= break/disp8 -25540 $translate-mu-length-stmt:size-1: -25541 (emit-save-size-to *(ebp+8) %ebx %edx) -25542 e9/jump $translate-mu-length-stmt:end/disp32 -25543 } -25544 # if elemsize is a power of 2 less than 256 -25545 { -25546 (power-of-2? %ecx *(ebp+0x10) *(ebp+0x14)) # => eax -25547 3d/compare-eax-and 0/imm32/false -25548 74/jump-if-= break/disp8 -25549 81 7/subop/compare %ecx 0xff/imm32 -25550 7f/jump-if-> break/disp8 -25551 $translate-mu-length-stmt:size-power-of-2: -25552 (emit-save-size-to *(ebp+8) %ebx %edx) -25553 (emit-divide-by-shift-right *(ebp+8) %edx %ecx) -25554 e9/jump $translate-mu-length-stmt:end/disp32 -25555 } -25556 # otherwise, the complex case -25557 # . emit register spills -25558 { -25559 $translate-mu-length-stmt:complex: -25560 (string-equal? %edx "eax") # => eax -25561 3d/compare-eax-and 0/imm32/false -25562 75/break-if-!= break/disp8 -25563 (emit-indent *(ebp+8) *Curr-block-depth) -25564 (write-buffered *(ebp+8) "50/push-eax\n") -25565 } -25566 { -25567 (string-equal? %edx "ecx") # => eax -25568 3d/compare-eax-and 0/imm32/false -25569 75/break-if-!= break/disp8 -25570 (emit-indent *(ebp+8) *Curr-block-depth) -25571 (write-buffered *(ebp+8) "51/push-ecx\n") -25572 } -25573 { -25574 (string-equal? %edx "edx") # => eax -25575 3d/compare-eax-and 0/imm32/false -25576 75/break-if-!= break/disp8 -25577 (emit-indent *(ebp+8) *Curr-block-depth) -25578 (write-buffered *(ebp+8) "52/push-edx\n") -25579 } -25580 # . -25581 (emit-save-size-to *(ebp+8) %ebx "eax") -25582 (emit-indent *(ebp+8) *Curr-block-depth) -25583 (write-buffered *(ebp+8) "31/xor %edx 2/r32/edx\n") -25584 (emit-indent *(ebp+8) *Curr-block-depth) -25585 (write-buffered *(ebp+8) "b9/copy-to-ecx ") -25586 (write-int32-hex-buffered *(ebp+8) %ecx) -25587 (write-buffered *(ebp+8) "/imm32\n") -25588 (emit-indent *(ebp+8) *Curr-block-depth) -25589 (write-buffered *(ebp+8) "f7 7/subop/idiv-eax-edx-by %ecx\n") -25590 { -25591 (string-equal? %edx "eax") # => eax -25592 3d/compare-eax-and 0/imm32/false -25593 75/break-if-!= break/disp8 -25594 (emit-indent *(ebp+8) *Curr-block-depth) -25595 (write-buffered *(ebp+8) "89/<- %") -25596 (write-buffered *(ebp+8) %edx) -25597 (write-buffered *(ebp+8) " 0/r32/eax\n") -25598 } -25599 # . emit register restores -25600 { -25601 (string-equal? %edx "edx") # => eax -25602 3d/compare-eax-and 0/imm32/false -25603 75/break-if-!= break/disp8 -25604 (emit-indent *(ebp+8) *Curr-block-depth) -25605 (write-buffered *(ebp+8) "5a/pop-to-edx\n") -25606 } -25607 { -25608 (string-equal? %edx "ecx") # => eax -25609 3d/compare-eax-and 0/imm32/false -25610 75/break-if-!= break/disp8 -25611 (emit-indent *(ebp+8) *Curr-block-depth) -25612 (write-buffered *(ebp+8) "59/pop-to-ecx\n") -25613 } -25614 { -25615 (string-equal? %edx "eax") # => eax -25616 3d/compare-eax-and 0/imm32/false -25617 75/break-if-!= break/disp8 -25618 (emit-indent *(ebp+8) *Curr-block-depth) -25619 (write-buffered *(ebp+8) "58/pop-to-eax\n") -25620 } -25621 $translate-mu-length-stmt:end: -25622 # . restore registers -25623 5e/pop-to-esi -25624 5b/pop-to-ebx -25625 5a/pop-to-edx -25626 59/pop-to-ecx -25627 58/pop-to-eax -25628 # . epilogue -25629 89/<- %esp 5/r32/ebp -25630 5d/pop-to-ebp -25631 c3/return -25632 -25633 array-element-size: # arr: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -25634 # . prologue -25635 55/push-ebp -25636 89/<- %ebp 4/r32/esp -25637 # -25638 (array-element-type-id *(ebp+8) *(ebp+0xc) *(ebp+0x10)) # => eax -25639 (size-of-type-id-as-array-element %eax) # => eax -25640 $array-element-size:end: -25641 # . epilogue -25642 89/<- %esp 5/r32/ebp -25643 5d/pop-to-ebp -25644 c3/return -25645 -25646 array-element-type-id: # v: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: type-id -25647 # precondition: n is positive -25648 # . prologue -25649 55/push-ebp -25650 89/<- %ebp 4/r32/esp -25651 # -25652 8b/-> *(ebp+8) 0/r32/eax -25653 # var t/eax: (addr type-tree) -25654 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -25655 # if t == 0 abort -25656 3d/compare-eax-with 0/imm32 -25657 0f 84/jump-if-== $array-element-type-id:error0/disp32 -25658 # if t->is-atom? abort -25659 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -25660 0f 85/jump-if-!= $array-element-type-id:error1/disp32 -25661 # if (t->left == addr) t = t->right -25662 { -25663 50/push-eax -25664 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -25665 (is-simple-mu-type? %eax 2) # addr => eax -25666 3d/compare-eax-with 0/imm32/false -25667 58/pop-to-eax -25668 74/jump-if-= break/disp8 -25669 $array-element-type-id:skip-addr: -25670 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -25671 } -25672 # if t == 0 abort -25673 3d/compare-eax-with 0/imm32 -25674 0f 84/jump-if-= $array-element-type-id:error2/disp32 -25675 # if t->is-atom? abort -25676 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -25677 0f 85/jump-if-!= $array-element-type-id:error2/disp32 -25678 # if t->left != array abort -25679 { -25680 50/push-eax -25681 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -25682 (is-simple-mu-type? %eax 3) # array => eax -25683 3d/compare-eax-with 0/imm32/false -25684 58/pop-to-eax -25685 $array-element-type-id:no-array: -25686 0f 84/jump-if-= $array-element-type-id:error2/disp32 +24604 75/jump-if-!= break/disp8 +24605 b8/copy-to-eax 8/imm32 +24606 eb/jump $size-of-type-id:end/disp8 # eax changes type from type-id to int +24607 } +24608 # if t is a slice, return 8 +24609 3d/compare-eax-and 0xc/imm32/slice +24610 { +24611 75/jump-if-!= break/disp8 +24612 b8/copy-to-eax 8/imm32 +24613 eb/jump $size-of-type-id:end/disp8 # eax changes type from type-id to int +24614 } +24615 # if t is a user-defined type, return its size +24616 # TODO: support non-atom type +24617 (find-typeinfo %eax %ecx) +24618 { +24619 81 7/subop/compare *ecx 0/imm32 +24620 74/jump-if-= break/disp8 +24621 $size-of-type-id:user-defined: +24622 (lookup *ecx *(ecx+4)) # => eax +24623 8b/-> *(eax+0xc) 0/r32/eax # Typeinfo-total-size-in-bytes +24624 eb/jump $size-of-type-id:end/disp8 +24625 } +24626 # otherwise return the word size +24627 b8/copy-to-eax 4/imm32 +24628 $size-of-type-id:end: +24629 # . reclaim locals +24630 81 0/subop/add %esp 8/imm32 +24631 # . restore registers +24632 59/pop-to-ecx +24633 # . epilogue +24634 89/<- %esp 5/r32/ebp +24635 5d/pop-to-ebp +24636 c3/return +24637 +24638 # Minor violation of our type system since it returns an addr. But we could +24639 # replace it with a handle some time. +24640 # Returns null if t is an atom. +24641 type-tail: # t: (addr type-tree) -> out/eax: (addr type-tree) +24642 # . prologue +24643 55/push-ebp +24644 89/<- %ebp 4/r32/esp +24645 # . save registers +24646 51/push-ecx +24647 # eax = 0 +24648 b8/copy-to-eax 0/imm32 +24649 # ecx = t +24650 8b/-> *(ebp+8) 1/r32/ecx +24651 $type-tail:check-atom: +24652 # if t->is-atom? return 0 +24653 81 7/subop/compare *ecx 0/imm32/false # Type-tree-is-atom +24654 0f 85/jump-if-!= $type-tail:end/disp32 +24655 # var tail = t->right +24656 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +24657 89/<- %ecx 0/r32/eax +24658 $type-tail:check-singleton: +24659 # if (tail->right == 0) return tail->left +24660 { +24661 81 7/subop/compare *(ecx+0xc) 0/imm32 # Type-tree-right +24662 75/jump-if-!= break/disp8 +24663 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24664 e9/jump $type-tail:end/disp32 +24665 } +24666 # if tail->right->left is an array-capacity, return tail->left +24667 { +24668 $type-tail:check-array-capacity: +24669 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +24670 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +24671 75/jump-if-!= break/disp8 +24672 $type-tail:check-array-capacity-1: +24673 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +24674 3d/compare-eax-and 0/imm32 +24675 74/jump-if-= break/disp8 +24676 $type-tail:check-array-capacity-2: +24677 (is-simple-mu-type? %eax 9) # array-capacity => eax +24678 3d/compare-eax-and 0/imm32/false +24679 74/jump-if-= break/disp8 +24680 $type-tail:array-capacity: +24681 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24682 eb/jump $type-tail:end/disp8 +24683 } +24684 $type-tail:check-compound-left: +24685 # if !tail->left->is-atom? return tail->left +24686 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24687 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +24688 74/jump-if-= $type-tail:end/disp8 +24689 $type-tail:return-tail: +24690 # return tail +24691 89/<- %eax 1/r32/ecx +24692 $type-tail:end: +24693 # . restore registers +24694 59/pop-to-ecx +24695 # . epilogue +24696 89/<- %esp 5/r32/ebp +24697 5d/pop-to-ebp +24698 c3/return +24699 +24700 type-equal?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean +24701 # . prologue +24702 55/push-ebp +24703 89/<- %ebp 4/r32/esp +24704 # . save registers +24705 51/push-ecx +24706 52/push-edx +24707 53/push-ebx +24708 # ecx = a +24709 8b/-> *(ebp+8) 1/r32/ecx +24710 # edx = b +24711 8b/-> *(ebp+0xc) 2/r32/edx +24712 $type-equal?:compare-addr: +24713 # if (a == b) return true +24714 8b/-> %ecx 0/r32/eax # Var-type +24715 39/compare %edx 0/r32/eax # Var-type +24716 b8/copy-to-eax 1/imm32/true +24717 0f 84/jump-if-= $type-equal?:end/disp32 +24718 $type-equal?:compare-null-a: +24719 # if (a == 0) return false +24720 b8/copy-to-eax 0/imm32/false +24721 81 7/subop/compare %ecx 0/imm32 +24722 0f 84/jump-if-= $type-equal?:end/disp32 +24723 $type-equal?:compare-null-b: +24724 # if (b == 0) return false +24725 81 7/subop/compare %edx 0/imm32 +24726 0f 84/jump-if-= $type-equal?:end/disp32 +24727 $type-equal?:compare-atom-state: +24728 # if (a->is-atom? != b->is-atom?) return false +24729 8b/-> *ecx 3/r32/ebx # Type-tree-is-atom +24730 39/compare *edx 3/r32/ebx # Type-tree-is-atom +24731 b8/copy-to-eax 0/imm32/false +24732 0f 85/jump-if-!= $type-equal?:end/disp32 +24733 # if a->is-atom? return (a->value == b->value) +24734 { +24735 $type-equal?:check-atom: +24736 81 7/subop/compare %ebx 0/imm32/false +24737 74/jump-if-= break/disp8 +24738 $type-equal?:is-atom: +24739 8b/-> *(ecx+4) 0/r32/eax # Type-tree-value +24740 39/compare *(edx+4) 0/r32/eax # Type-tree-value +24741 0f 94/set-if-= %al +24742 81 4/subop/and %eax 0xff/imm32 +24743 e9/jump $type-equal?:end/disp32 +24744 } +24745 $type-equal?:check-left: +24746 # if (!type-equal?(a->left, b->left)) return false +24747 (lookup *(ecx+4) *(ecx+8)) # Type-tree-left Type-tree-left => eax +24748 89/<- %ebx 0/r32/eax +24749 (lookup *(edx+4) *(edx+8)) # Type-tree-left Type-tree-left => eax +24750 (type-equal? %eax %ebx) # => eax +24751 3d/compare-eax-and 0/imm32/false +24752 74/jump-if-= $type-equal?:end/disp8 +24753 $type-equal?:check-right: +24754 # return type-equal?(a->right, b->right) +24755 (lookup *(ecx+0xc) *(ecx+0x10)) # Type-tree-right Type-tree-right => eax +24756 89/<- %ebx 0/r32/eax +24757 (lookup *(edx+0xc) *(edx+0x10)) # Type-tree-right Type-tree-right => eax +24758 (type-equal? %eax %ebx) # => eax +24759 $type-equal?:end: +24760 # . restore registers +24761 5b/pop-to-ebx +24762 5a/pop-to-edx +24763 59/pop-to-ecx +24764 # . epilogue +24765 89/<- %esp 5/r32/ebp +24766 5d/pop-to-ebp +24767 c3/return +24768 +24769 ####################################################### +24770 # Code-generation +24771 ####################################################### +24772 +24773 == data +24774 +24775 # Global state added to each var record when performing code-generation. +24776 Curr-local-stack-offset: # (addr int) +24777 0/imm32 +24778 +24779 == code +24780 +24781 emit-subx: # out: (addr buffered-file), err: (addr buffered-file), ed: (addr exit-descriptor) +24782 # . prologue +24783 55/push-ebp +24784 89/<- %ebp 4/r32/esp +24785 # . save registers +24786 50/push-eax +24787 # var curr/eax: (addr function) = *Program->functions +24788 (lookup *_Program-functions *_Program-functions->payload) # => eax +24789 { +24790 # if (curr == null) break +24791 3d/compare-eax-and 0/imm32 +24792 0f 84/jump-if-= break/disp32 +24793 (emit-subx-function *(ebp+8) %eax *(ebp+0xc) *(ebp+0x10)) +24794 # curr = lookup(curr->next) +24795 (lookup *(eax+0x20) *(eax+0x24)) # Function-next Function-next => eax +24796 e9/jump loop/disp32 +24797 } +24798 $emit-subx:end: +24799 # . restore registers +24800 58/pop-to-eax +24801 # . epilogue +24802 89/<- %esp 5/r32/ebp +24803 5d/pop-to-ebp +24804 c3/return +24805 +24806 emit-subx-function: # out: (addr buffered-file), f: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +24807 # . prologue +24808 55/push-ebp +24809 89/<- %ebp 4/r32/esp +24810 # some preprocessing +24811 (populate-mu-type-offsets-in-inouts *(ebp+0xc)) +24812 # . save registers +24813 50/push-eax +24814 51/push-ecx +24815 52/push-edx +24816 # initialize some global state +24817 c7 0/subop/copy *Curr-block-depth 1/imm32 # Important: keep this in sync with the parse phase +24818 c7 0/subop/copy *Curr-local-stack-offset 0/imm32 +24819 # ecx = f +24820 8b/-> *(ebp+0xc) 1/r32/ecx +24821 # var vars/edx: (stack (addr var) 256) +24822 81 5/subop/subtract %esp 0xc00/imm32 +24823 68/push 0xc00/imm32/size +24824 68/push 0/imm32/top +24825 89/<- %edx 4/r32/esp +24826 # var name/eax: (addr array byte) = lookup(f->name) +24827 (lookup *ecx *(ecx+4)) # Function-name Function-name => eax +24828 # +24829 (write-buffered *(ebp+8) %eax) +24830 (write-buffered *(ebp+8) ":\n") +24831 (emit-subx-prologue *(ebp+8)) +24832 # var body/eax: (addr block) = lookup(f->body) +24833 (lookup *(ecx+0x18) *(ecx+0x1c)) # Function-body Function-body => eax +24834 # +24835 (emit-subx-block *(ebp+8) %eax %edx *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +24836 (emit-subx-epilogue *(ebp+8)) +24837 # TODO: validate that *Curr-block-depth and *Curr-local-stack-offset have +24838 # been cleaned up +24839 $emit-subx-function:end: +24840 # . reclaim locals +24841 81 0/subop/add %esp 0xc08/imm32 +24842 # . restore registers +24843 5a/pop-to-edx +24844 59/pop-to-ecx +24845 58/pop-to-eax +24846 # . epilogue +24847 89/<- %esp 5/r32/ebp +24848 5d/pop-to-ebp +24849 c3/return +24850 +24851 populate-mu-type-offsets-in-inouts: # f: (addr function) +24852 # . prologue +24853 55/push-ebp +24854 89/<- %ebp 4/r32/esp +24855 # . save registers +24856 50/push-eax +24857 51/push-ecx +24858 52/push-edx +24859 53/push-ebx +24860 57/push-edi +24861 # var next-offset/edx: int = 8 +24862 ba/copy-to-edx 8/imm32 +24863 # var curr/ecx: (addr list var) = lookup(f->inouts) +24864 8b/-> *(ebp+8) 1/r32/ecx +24865 (lookup *(ecx+8) *(ecx+0xc)) # Function-inouts Function-inouts => eax +24866 89/<- %ecx 0/r32/eax +24867 { +24868 $populate-mu-type-offsets-in-inouts:loop: +24869 81 7/subop/compare %ecx 0/imm32 +24870 74/jump-if-= break/disp8 +24871 # var v/ebx: (addr var) = lookup(curr->value) +24872 (lookup *ecx *(ecx+4)) # List-value List-value => eax +24873 89/<- %ebx 0/r32/eax +24874 #? (lookup *ebx *(ebx+4)) +24875 #? (write-buffered Stderr "setting offset of fn inout ") +24876 #? (write-buffered Stderr %eax) +24877 #? (write-buffered Stderr "@") +24878 #? (write-int32-hex-buffered Stderr %ebx) +24879 #? (write-buffered Stderr " to ") +24880 #? (write-int32-hex-buffered Stderr %edx) +24881 #? (write-buffered Stderr Newline) +24882 #? (flush Stderr) +24883 # v->offset = next-offset +24884 89/<- *(ebx+0x14) 2/r32/edx # Var-offset +24885 # next-offset += size-of(v) +24886 (size-of %ebx) # => eax +24887 01/add-to %edx 0/r32/eax +24888 # curr = lookup(curr->next) +24889 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +24890 89/<- %ecx 0/r32/eax +24891 # +24892 eb/jump loop/disp8 +24893 } +24894 $populate-mu-type-offsets-in-inouts:end: +24895 # . restore registers +24896 5f/pop-to-edi +24897 5b/pop-to-ebx +24898 5a/pop-to-edx +24899 59/pop-to-ecx +24900 58/pop-to-eax +24901 # . epilogue +24902 89/<- %esp 5/r32/ebp +24903 5d/pop-to-ebp +24904 c3/return +24905 +24906 emit-subx-stmt-list: # out: (addr buffered-file), stmts: (addr list stmt), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +24907 # . prologue +24908 55/push-ebp +24909 89/<- %ebp 4/r32/esp +24910 # . save registers +24911 50/push-eax +24912 51/push-ecx +24913 53/push-ebx +24914 56/push-esi +24915 # esi = stmts +24916 8b/-> *(ebp+0xc) 6/r32/esi +24917 # +24918 { +24919 $emit-subx-stmt-list:loop: +24920 81 7/subop/compare %esi 0/imm32 +24921 0f 84/jump-if-= break/disp32 +24922 # var curr-stmt/ecx: (addr stmt) = lookup(stmts->value) +24923 (lookup *esi *(esi+4)) # List-value List-value => eax +24924 89/<- %ecx 0/r32/eax +24925 { +24926 $emit-subx-stmt-list:check-for-block: +24927 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag +24928 75/jump-if-!= break/disp8 +24929 $emit-subx-stmt-list:block: +24930 (emit-subx-block *(ebp+8) %ecx *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +24931 } +24932 { +24933 $emit-subx-stmt-list:check-for-stmt: +24934 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag +24935 0f 85/jump-if-!= break/disp32 +24936 $emit-subx-stmt-list:stmt1: +24937 { +24938 (is-mu-branch? %ecx) # => eax +24939 3d/compare-eax-and 0/imm32/false +24940 0f 84/jump-if-= break/disp32 +24941 $emit-subx-stmt-list:branch-stmt: +24942 +-- 25 lines: # unconditional return ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +24967 +-- 27 lines: # unconditional loops -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +24994 +-- 16 lines: # unconditional breaks ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +25010 +-- 38 lines: # simple conditional branches without a target ------------------------------------------------------------------------------------------------------------------------------------------------------- +25048 +-- 19 lines: # conditional branches with an explicit target ------------------------------------------------------------------------------------------------------------------------------------------------------- +25067 } +25068 $emit-subx-stmt-list:1-to-1: +25069 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x18) *(ebp+0x1c)) +25070 e9/jump $emit-subx-stmt-list:continue/disp32 +25071 } +25072 { +25073 $emit-subx-stmt-list:check-for-var-def: +25074 81 7/subop/compare *ecx 2/imm32/var-def # Stmt-tag +25075 75/jump-if-!= break/disp8 +25076 $emit-subx-stmt-list:var-def: +25077 (emit-subx-var-def *(ebp+8) %ecx) +25078 (push *(ebp+0x10) *(ecx+4)) # Vardef-var +25079 (push *(ebp+0x10) *(ecx+8)) # Vardef-var +25080 (push *(ebp+0x10) 0) # Live-var-register-spilled = 0 for vars on the stack +25081 # +25082 eb/jump $emit-subx-stmt-list:continue/disp8 +25083 } +25084 { +25085 $emit-subx-stmt-list:check-for-reg-var-def: +25086 81 7/subop/compare *ecx 3/imm32/reg-var-def # Stmt-tag +25087 0f 85/jump-if-!= break/disp32 +25088 $emit-subx-stmt-list:reg-var-def: +25089 # TODO: ensure that there's exactly one output +25090 (push-output-and-maybe-emit-spill *(ebp+8) %ecx *(ebp+0x10) %esi *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +25091 # emit the instruction as usual +25092 (emit-subx-stmt *(ebp+8) %ecx Primitives *(ebp+0x18) *(ebp+0x1c)) +25093 # +25094 eb/jump $emit-subx-stmt-list:continue/disp8 +25095 } +25096 $emit-subx-stmt-list:continue: +25097 # TODO: raise an error on unrecognized Stmt-tag +25098 (lookup *(esi+8) *(esi+0xc)) # List-next List-next => eax +25099 89/<- %esi 0/r32/eax +25100 e9/jump loop/disp32 +25101 } +25102 $emit-subx-stmt-list:emit-cleanup: +25103 (emit-cleanup-code-until-depth *(ebp+8) *(ebp+0x10) *Curr-block-depth) +25104 $emit-subx-stmt-list:clean-up: +25105 (clean-up-stack-offset-state *(ebp+0x10) *Curr-block-depth) +25106 (clean-up-blocks *(ebp+0x10) *Curr-block-depth *(ebp+0x14)) +25107 $emit-subx-stmt-list:end: +25108 # . restore registers +25109 5e/pop-to-esi +25110 5b/pop-to-ebx +25111 59/pop-to-ecx +25112 58/pop-to-eax +25113 # . epilogue +25114 89/<- %esp 5/r32/ebp +25115 5d/pop-to-ebp +25116 c3/return +25117 +25118 # 'later-stmts' includes 'stmt', but will behave the same even without it; reg-var-def stmts are guaranteed not to write to function outputs. +25119 push-output-and-maybe-emit-spill: # out: (addr buffered-file), stmt: (addr reg-var-def), vars: (addr stack (handle var)), later-stmts: (addr list stmt), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +25120 # . prologue +25121 55/push-ebp +25122 89/<- %ebp 4/r32/esp +25123 # . save registers +25124 50/push-eax +25125 51/push-ecx +25126 52/push-edx +25127 # ecx = stmt +25128 8b/-> *(ebp+0xc) 1/r32/ecx +25129 # var sv/eax: (addr stmt-var) = lookup(curr-stmt->outputs) +25130 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax +25131 # TODO: assert !sv->is-deref? +25132 # var v/ecx: (addr var) = lookup(sv->value) +25133 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +25134 89/<- %ecx 0/r32/eax +25135 # v->block-depth = *Curr-block-depth +25136 8b/-> *Curr-block-depth 0/r32/eax +25137 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth +25138 #? (write-buffered Stderr "var ") +25139 #? (lookup *ecx *(ecx+4)) +25140 #? (write-buffered Stderr %eax) +25141 #? (write-buffered Stderr " at depth ") +25142 #? (write-int32-hex-buffered Stderr *(ecx+0x10)) +25143 #? (write-buffered Stderr Newline) +25144 #? (flush Stderr) +25145 # ensure that v is in a register +25146 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +25147 0f 84/jump-if-= $push-output-and-maybe-emit-spill:abort/disp32 +25148 # var emit-spill?/edx: boolean = not-yet-spilled-this-block? && will-not-write-some-register?(fn) +25149 (not-yet-spilled-this-block? %ecx *(ebp+0x10)) # => eax +25150 89/<- %edx 0/r32/eax +25151 3d/compare-eax-and 0/imm32/false +25152 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32 +25153 (will-not-write-some-register? %ecx *(ebp+0x14) *(ebp+0x18)) # => eax +25154 89/<- %edx 0/r32/eax +25155 # check emit-spill? +25156 3d/compare-eax-and 0/imm32/false +25157 0f 84/jump-if-= $push-output-and-maybe-emit-spill:push/disp32 +25158 # TODO: assert(size-of(output) == 4) +25159 # *Curr-local-stack-offset -= 4 +25160 81 5/subop/subtract *Curr-local-stack-offset 4/imm32 +25161 # emit spill +25162 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax +25163 (emit-push-register *(ebp+8) %eax) +25164 $push-output-and-maybe-emit-spill:push: +25165 8b/-> *(ebp+0xc) 1/r32/ecx +25166 (lookup *(ecx+0x14) *(ecx+0x18)) # Regvardef-outputs Regvardef-outputs => eax +25167 # push(vars, {sv->value, emit-spill?}) +25168 (push *(ebp+0x10) *eax) # Stmt-var-value +25169 (push *(ebp+0x10) *(eax+4)) # Stmt-var-value +25170 (push *(ebp+0x10) %edx) +25171 $push-output-and-maybe-emit-spill:end: +25172 # . restore registers +25173 5a/pop-to-edx +25174 59/pop-to-ecx +25175 58/pop-to-eax +25176 # . epilogue +25177 89/<- %esp 5/r32/ebp +25178 5d/pop-to-ebp +25179 c3/return +25180 +25181 $push-output-and-maybe-emit-spill:abort: +25182 # error("var '" var->name "' initialized from an instruction must live in a register\n") +25183 (write-buffered *(ebp+0x1c) "var '") +25184 (write-buffered *(ebp+0x1c) *eax) # Var-name +25185 (write-buffered *(ebp+0x1c) "' initialized from an instruction must live in a register\n") +25186 (flush *(ebp+0x1c)) +25187 (stop *(ebp+0x20) 1) +25188 # never gets here +25189 +25190 emit-subx-cleanup-and-unconditional-nonlocal-branch: # out: (addr buffered-file), stmt: (addr stmt1), vars: (addr stack live-var) +25191 # . prologue +25192 55/push-ebp +25193 89/<- %ebp 4/r32/esp +25194 # . save registers +25195 50/push-eax +25196 51/push-ecx +25197 # ecx = stmt +25198 8b/-> *(ebp+0xc) 1/r32/ecx +25199 # var target/eax: (addr array byte) = curr-stmt->inouts->value->name +25200 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +25201 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +25202 (lookup *eax *(eax+4)) # Var-name Var-name => eax +25203 # clean up until target block +25204 (emit-cleanup-code-until-target *(ebp+8) *(ebp+0x10) %eax) +25205 # emit jump to target block +25206 (emit-indent *(ebp+8) *Curr-block-depth) +25207 (write-buffered *(ebp+8) "e9/jump ") +25208 (write-buffered *(ebp+8) %eax) +25209 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +25210 (string-starts-with? %eax "break") +25211 3d/compare-eax-and 0/imm32/false +25212 { +25213 74/jump-if-= break/disp8 +25214 (write-buffered *(ebp+8) ":break/disp32\n") +25215 eb/jump $emit-subx-cleanup-and-unconditional-nonlocal-branch:end/disp8 +25216 } +25217 (write-buffered *(ebp+8) ":loop/disp32\n") +25218 $emit-subx-cleanup-and-unconditional-nonlocal-branch:end: +25219 # . restore registers +25220 59/pop-to-ecx +25221 58/pop-to-eax +25222 # . epilogue +25223 89/<- %esp 5/r32/ebp +25224 5d/pop-to-ebp +25225 c3/return +25226 +25227 emit-outputs: # out: (addr buffered-file), return-stmt: (addr stmt1), fn: (addr function) +25228 # pseudocode: +25229 # for every inout, output in return-stmt, fn->outputs +25230 # if inout is a literal +25231 # c7 0/subop/copy %output inout/imm32 +25232 # otherwise +25233 # 8b/-> inout %output +25234 # +25235 # . prologue +25236 55/push-ebp +25237 89/<- %ebp 4/r32/esp +25238 # . save registers +25239 50/push-eax +25240 51/push-ecx +25241 56/push-esi +25242 57/push-edi +25243 # var curr-inout/esi: (addr stmt-var) = return-stmt->inouts +25244 8b/-> *(ebp+0xc) 0/r32/eax +25245 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax +25246 89/<- %esi 0/r32/eax +25247 # var curr-output/edi: (addr list var) = fn->outputs +25248 8b/-> *(ebp+0x10) 0/r32/eax +25249 (lookup *(eax+0x10) *(eax+0x14)) # Function-outputs Function-outputs => eax +25250 89/<- %edi 0/r32/eax +25251 { +25252 $emit-outputs:loop: +25253 81 7/subop/compare %esi 0/imm32 +25254 0f 84/jump-if-= break/disp32 +25255 # emit copy to output register +25256 # var curr-var/ecx = lookup(curr-inout->value) +25257 (lookup *esi *(esi+4)) # Stmt-var-value Stmt-var-value => eax +25258 89/<- %ecx 0/r32/eax +25259 # if curr-var is a literal, emit copy of a literal to the output +25260 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +25261 (is-simple-mu-type? %eax 0) # literal => eax +25262 { +25263 3d/compare-eax-and 0/imm32/false +25264 0f 84/jump-if-= break/disp32 +25265 (emit-indent *(ebp+8) *Curr-block-depth) +25266 (write-buffered *(ebp+8) "c7 0/subop/copy %") +25267 (lookup *edi *(edi+4)) # List-value List-value => eax +25268 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +25269 (write-buffered *(ebp+8) %eax) +25270 (write-buffered *(ebp+8) " ") +25271 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +25272 (write-buffered *(ebp+8) %eax) +25273 (write-buffered *(ebp+8) "/imm32\n") +25274 e9/jump $emit-outputs:continue/disp32 +25275 } +25276 # if the non-literal is a register starting with "x", emit a floating-point copy +25277 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax +25278 { +25279 3d/compare-eax-and 0/imm32 +25280 0f 84/jump-if-= break/disp32 +25281 8a/copy-byte *(eax+4) 0/r32/AL +25282 81 4/subop/and %eax 0xff/imm32 +25283 3d/compare-eax-and 0x78/imm32/x +25284 0f 85/jump-if-!= break/disp32 +25285 (emit-indent *(ebp+8) *Curr-block-depth) +25286 (write-buffered *(ebp+8) "f3 0f 10/->") +25287 (emit-subx-var-as-rm32 *(ebp+8) %esi) +25288 (write-buffered *(ebp+8) " ") +25289 (lookup *edi *(edi+4)) # List-value List-value => eax +25290 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +25291 (get Mu-registers %eax 0xc "Mu-registers") # => eax +25292 (write-int32-hex-buffered *(ebp+8) *eax) +25293 (write-buffered *(ebp+8) "/x32\n") +25294 e9/jump $emit-outputs:continue/disp32 +25295 } +25296 # otherwise emit an integer copy +25297 (emit-indent *(ebp+8) *Curr-block-depth) +25298 (write-buffered *(ebp+8) "8b/->") +25299 (emit-subx-var-as-rm32 *(ebp+8) %esi) +25300 (write-buffered *(ebp+8) " ") +25301 (lookup *edi *(edi+4)) # List-value List-value => eax +25302 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +25303 (get Mu-registers %eax 0xc "Mu-registers") # => eax +25304 (write-int32-hex-buffered *(ebp+8) *eax) +25305 (write-buffered *(ebp+8) "/r32\n") +25306 $emit-outputs:continue: +25307 # curr-inout = curr-inout->next +25308 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +25309 89/<- %esi 0/r32/eax +25310 # curr-output = curr-output->next +25311 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax +25312 89/<- %edi 0/r32/eax +25313 # +25314 e9/jump loop/disp32 +25315 } +25316 $emit-outputs:end: +25317 # . restore registers +25318 5f/pop-to-edi +25319 5e/pop-to-esi +25320 59/pop-to-ecx +25321 58/pop-to-eax +25322 # . epilogue +25323 89/<- %esp 5/r32/ebp +25324 5d/pop-to-ebp +25325 c3/return +25326 +25327 is-mu-branch?: # stmt: (addr stmt1) -> result/eax: boolean +25328 # . prologue +25329 55/push-ebp +25330 89/<- %ebp 4/r32/esp +25331 # . save registers +25332 51/push-ecx +25333 # ecx = lookup(stmt->operation) +25334 8b/-> *(ebp+8) 1/r32/ecx +25335 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +25336 89/<- %ecx 0/r32/eax +25337 # if (stmt->operation starts with "loop") return true +25338 (string-starts-with? %ecx "loop") # => eax +25339 3d/compare-eax-and 0/imm32/false +25340 75/jump-if-not-equal $is-mu-branch?:end/disp8 +25341 # if (stmt->operation starts with "break") return true +25342 (string-starts-with? %ecx "break") # => eax +25343 3d/compare-eax-and 0/imm32/false +25344 75/jump-if-not-equal $is-mu-branch?:end/disp8 +25345 # otherwise return (stmt->operation starts with "return") +25346 (string-starts-with? %ecx "return") # => eax +25347 $is-mu-branch?:end: +25348 # . restore registers +25349 59/pop-to-ecx +25350 # . epilogue +25351 89/<- %esp 5/r32/ebp +25352 5d/pop-to-ebp +25353 c3/return +25354 +25355 emit-reverse-break: # out: (addr buffered-file), stmt: (addr stmt1) +25356 # . prologue +25357 55/push-ebp +25358 89/<- %ebp 4/r32/esp +25359 # . save registers +25360 50/push-eax +25361 # eax = stmt +25362 8b/-> *(ebp+0xc) 0/r32/eax +25363 # +25364 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +25365 (get Reverse-branch %eax 0x10 "reverse-branch: ") # => eax: (addr handle array byte) +25366 (emit-indent *(ebp+8) *Curr-block-depth) +25367 (lookup *eax *(eax+4)) # => eax +25368 (write-buffered *(ebp+8) %eax) +25369 (write-buffered *(ebp+8) " break/disp32\n") +25370 $emit-reverse-break:end: +25371 # . restore registers +25372 58/pop-to-eax +25373 # . epilogue +25374 89/<- %esp 5/r32/ebp +25375 5d/pop-to-ebp +25376 c3/return +25377 +25378 == data +25379 +25380 # Table from Mu branch instructions to the reverse SubX opcodes for them. +25381 Reverse-branch: # (table (handle array byte) (handle array byte)) +25382 # a table is a stream +25383 0x1c0/imm32/write +25384 0/imm32/read +25385 0x1c0/imm32/size +25386 # data +25387 0x11/imm32/alloc-id _string-break-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 +25388 0x11/imm32/alloc-id _string-loop-if-=/imm32 0x11/imm32/alloc-id _string_0f_85_jump_label/imm32 +25389 0x11/imm32/alloc-id _string-break-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 +25390 0x11/imm32/alloc-id _string-loop-if-!=/imm32 0x11/imm32/alloc-id _string_0f_84_jump_label/imm32 +25391 0x11/imm32/alloc-id _string-break-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 +25392 0x11/imm32/alloc-id _string-loop-if-</imm32 0x11/imm32/alloc-id _string_0f_8d_jump_label/imm32 +25393 0x11/imm32/alloc-id _string-break-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 +25394 0x11/imm32/alloc-id _string-loop-if->/imm32 0x11/imm32/alloc-id _string_0f_8e_jump_label/imm32 +25395 0x11/imm32/alloc-id _string-break-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +25396 0x11/imm32/alloc-id _string-loop-if-<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +25397 0x11/imm32/alloc-id _string-break-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 +25398 0x11/imm32/alloc-id _string-loop-if->=/imm32 0x11/imm32/alloc-id _string_0f_8c_jump_label/imm32 +25399 0x11/imm32/alloc-id _string-break-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 +25400 0x11/imm32/alloc-id _string-loop-if-addr</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 +25401 0x11/imm32/alloc-id _string-break-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 +25402 0x11/imm32/alloc-id _string-loop-if-addr>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 +25403 0x11/imm32/alloc-id _string-break-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +25404 0x11/imm32/alloc-id _string-loop-if-addr<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +25405 0x11/imm32/alloc-id _string-break-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 +25406 0x11/imm32/alloc-id _string-loop-if-addr>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 +25407 0x11/imm32/alloc-id _string-break-if-float</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 +25408 0x11/imm32/alloc-id _string-loop-if-float</imm32 0x11/imm32/alloc-id _string_0f_83_jump_label/imm32 +25409 0x11/imm32/alloc-id _string-break-if-float>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 +25410 0x11/imm32/alloc-id _string-loop-if-float>/imm32 0x11/imm32/alloc-id _string_0f_86_jump_label/imm32 +25411 0x11/imm32/alloc-id _string-break-if-float<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +25412 0x11/imm32/alloc-id _string-loop-if-float<=/imm32 0x11/imm32/alloc-id _string_0f_87_jump_label/imm32 +25413 0x11/imm32/alloc-id _string-break-if-float>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 +25414 0x11/imm32/alloc-id _string-loop-if-float>=/imm32 0x11/imm32/alloc-id _string_0f_82_jump_label/imm32 +25415 +25416 == code +25417 +25418 emit-unconditional-jump-to-depth: # out: (addr buffered-file), vars: (addr stack live-var), depth: int, label-suffix: (addr array byte) +25419 # . prologue +25420 55/push-ebp +25421 89/<- %ebp 4/r32/esp +25422 # . save registers +25423 50/push-eax +25424 51/push-ecx +25425 52/push-edx +25426 53/push-ebx +25427 56/push-esi +25428 # ecx = vars +25429 8b/-> *(ebp+0xc) 1/r32/ecx +25430 # var eax: int = vars->top +25431 8b/-> *ecx 0/r32/eax +25432 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] +25433 8d/copy-address *(ecx+eax-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size +25434 # var min/ecx: (addr handle var) = vars->data +25435 8d/copy-address *(ecx+8) 1/r32/ecx +25436 # edx = depth +25437 8b/-> *(ebp+0x10) 2/r32/edx +25438 { +25439 $emit-unconditional-jump-to-depth:loop: +25440 # if (curr < min) break +25441 39/compare %esi 1/r32/ecx +25442 0f 82/jump-if-addr< break/disp32 +25443 # var v/ebx: (addr var) = lookup(*curr) +25444 (lookup *esi *(esi+4)) # => eax +25445 89/<- %ebx 0/r32/eax +25446 # if (v->block-depth < until-block-depth) break +25447 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth +25448 0f 8c/jump-if-< break/disp32 +25449 { +25450 $emit-unconditional-jump-to-depth:check: +25451 # if v->block-depth != until-block-depth, continue +25452 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth +25453 0f 85/jump-if-!= break/disp32 +25454 $emit-unconditional-jump-to-depth:depth-found: +25455 # if v is not a literal, continue +25456 (size-of %ebx) # => eax +25457 3d/compare-eax-and 0/imm32 +25458 0f 85/jump-if-!= break/disp32 +25459 $emit-unconditional-jump-to-depth:label-found: +25460 # emit unconditional jump, then return +25461 (emit-indent *(ebp+8) *Curr-block-depth) +25462 (write-buffered *(ebp+8) "e9/jump ") +25463 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +25464 (write-buffered *(ebp+8) %eax) +25465 (write-buffered *(ebp+8) ":") +25466 (write-buffered *(ebp+8) *(ebp+0x14)) +25467 (write-buffered *(ebp+8) "/disp32\n") +25468 eb/jump $emit-unconditional-jump-to-depth:end/disp8 +25469 } +25470 # curr -= 12 +25471 81 5/subop/subtract %esi 0xc/imm32 +25472 e9/jump loop/disp32 +25473 } +25474 # TODO: error if no label at 'depth' was found +25475 $emit-unconditional-jump-to-depth:end: +25476 # . restore registers +25477 5e/pop-to-esi +25478 5b/pop-to-ebx +25479 5a/pop-to-edx +25480 59/pop-to-ecx +25481 58/pop-to-eax +25482 # . epilogue +25483 89/<- %esp 5/r32/ebp +25484 5d/pop-to-ebp +25485 c3/return +25486 +25487 # emit clean-up code for 'vars' until some block depth +25488 # doesn't actually modify 'vars' so we need traverse manually inside the stack +25489 emit-cleanup-code-until-depth: # out: (addr buffered-file), vars: (addr stack live-var), until-block-depth: int +25490 # . prologue +25491 55/push-ebp +25492 89/<- %ebp 4/r32/esp +25493 # . save registers +25494 50/push-eax +25495 51/push-ecx +25496 52/push-edx +25497 53/push-ebx +25498 56/push-esi +25499 #? (write-buffered Stderr "--- cleanup\n") +25500 #? (flush Stderr) +25501 # ecx = vars +25502 8b/-> *(ebp+0xc) 1/r32/ecx +25503 # var esi: int = vars->top +25504 8b/-> *ecx 6/r32/esi +25505 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] +25506 8d/copy-address *(ecx+esi-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size +25507 # var min/ecx: (addr handle var) = vars->data +25508 81 0/subop/add %ecx 8/imm32 +25509 # edx = until-block-depth +25510 8b/-> *(ebp+0x10) 2/r32/edx +25511 { +25512 $emit-cleanup-code-until-depth:loop: +25513 # if (curr < min) break +25514 39/compare %esi 1/r32/ecx +25515 0f 82/jump-if-addr< break/disp32 +25516 # var v/ebx: (addr var) = lookup(*curr) +25517 (lookup *esi *(esi+4)) # => eax +25518 89/<- %ebx 0/r32/eax +25519 #? (lookup *ebx *(ebx+4)) # Var-name +25520 #? (write-buffered Stderr "var ") +25521 #? (write-buffered Stderr %eax) +25522 #? (write-buffered Stderr Newline) +25523 #? (flush Stderr) +25524 # if (v->block-depth < until-block-depth) break +25525 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth +25526 0f 8c/jump-if-< break/disp32 +25527 # if v is in a register +25528 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register +25529 { +25530 0f 84/jump-if-= break/disp32 +25531 { +25532 $emit-cleanup-code-until-depth:check-for-previous-spill: +25533 8b/-> *(esi+8) 0/r32/eax # Live-var-register-spilled +25534 3d/compare-eax-and 0/imm32/false +25535 74/jump-if-= break/disp8 +25536 $emit-cleanup-code-until-depth:reclaim-var-in-register: +25537 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +25538 (emit-pop-register *(ebp+8) %eax) +25539 } +25540 eb/jump $emit-cleanup-code-until-depth:continue/disp8 +25541 } +25542 # otherwise v is on the stack +25543 { +25544 75/jump-if-!= break/disp8 +25545 $emit-cleanup-code-until-depth:var-on-stack: +25546 (size-of %ebx) # => eax +25547 # don't emit code for labels +25548 3d/compare-eax-and 0/imm32 +25549 74/jump-if-= break/disp8 +25550 $emit-cleanup-code-until-depth:reclaim-var-on-stack: +25551 (emit-indent *(ebp+8) *Curr-block-depth) +25552 (write-buffered *(ebp+8) "81 0/subop/add %esp ") +25553 (write-int32-hex-buffered *(ebp+8) %eax) +25554 (write-buffered *(ebp+8) "/imm32\n") +25555 } +25556 $emit-cleanup-code-until-depth:continue: +25557 # curr -= 12 +25558 81 5/subop/subtract %esi 0xc/imm32 +25559 e9/jump loop/disp32 +25560 } +25561 $emit-cleanup-code-until-depth:end: +25562 # . restore registers +25563 5e/pop-to-esi +25564 5b/pop-to-ebx +25565 5a/pop-to-edx +25566 59/pop-to-ecx +25567 58/pop-to-eax +25568 # . epilogue +25569 89/<- %esp 5/r32/ebp +25570 5d/pop-to-ebp +25571 c3/return +25572 +25573 # emit clean-up code for 'vars' that don't conflict with output registers +25574 # doesn't actually modify 'vars' so we need traverse manually inside the stack +25575 emit-cleanup-code-for-non-outputs: # out: (addr buffered-file), vars: (addr stack live-var), fn: (addr function) +25576 # . prologue +25577 55/push-ebp +25578 89/<- %ebp 4/r32/esp +25579 # . save registers +25580 50/push-eax +25581 51/push-ecx +25582 52/push-edx +25583 53/push-ebx +25584 56/push-esi +25585 57/push-edi +25586 # ecx = vars +25587 8b/-> *(ebp+0xc) 1/r32/ecx +25588 # var esi: int = vars->top +25589 8b/-> *ecx 6/r32/esi +25590 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] +25591 8d/copy-address *(ecx+esi-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size +25592 # var min/ecx: (addr handle var) = vars->data +25593 81 0/subop/add %ecx 8/imm32 +25594 { +25595 $emit-cleanup-code-for-non-outputs:loop: +25596 # if (curr < min) break +25597 39/compare %esi 1/r32/ecx +25598 0f 82/jump-if-addr< break/disp32 +25599 # var v/ebx: (addr var) = lookup(*curr) +25600 (lookup *esi *(esi+4)) # => eax +25601 89/<- %ebx 0/r32/eax +25602 # if v is in a register +25603 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register +25604 { +25605 0f 84/jump-if-= break/disp32 +25606 { +25607 $emit-cleanup-code-for-non-outputs:check-for-previous-spill: +25608 8b/-> *(esi+8) 0/r32/eax # Live-var-register-spilled +25609 3d/compare-eax-and 0/imm32/false +25610 0f 84/jump-if-= break/disp32 +25611 $emit-cleanup-code-for-non-outputs:reclaim-var-in-register: +25612 # var reg/edi: (addr array name) = v->register +25613 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +25614 89/<- %edi 0/r32/eax +25615 # if reg is not in function outputs, emit a pop +25616 (reg-in-function-outputs? *(ebp+0x10) %edi) # => eax +25617 3d/compare-eax-and 0/imm32/false +25618 { +25619 75/jump-if-!= break/disp8 +25620 (emit-pop-register *(ebp+8) %edi) +25621 eb/jump $emit-cleanup-code-for-non-outputs:reclaim-var-in-register-done/disp8 +25622 } +25623 # otherwise just drop it from the stack +25624 (emit-indent *(ebp+8) *Curr-block-depth) +25625 (write-buffered *(ebp+8) "81 0/subop/add %esp 4/imm32\n") +25626 } +25627 $emit-cleanup-code-for-non-outputs:reclaim-var-in-register-done: +25628 eb/jump $emit-cleanup-code-for-non-outputs:continue/disp8 +25629 } +25630 # otherwise v is on the stack +25631 { +25632 75/jump-if-!= break/disp8 +25633 $emit-cleanup-code-for-non-outputs:var-on-stack: +25634 (size-of %ebx) # => eax +25635 # don't emit code for labels +25636 3d/compare-eax-and 0/imm32 +25637 74/jump-if-= break/disp8 +25638 $emit-cleanup-code-for-non-outputs:reclaim-var-on-stack: +25639 (emit-indent *(ebp+8) *Curr-block-depth) +25640 (write-buffered *(ebp+8) "81 0/subop/add %esp ") +25641 (write-int32-hex-buffered *(ebp+8) %eax) +25642 (write-buffered *(ebp+8) "/imm32\n") +25643 } +25644 $emit-cleanup-code-for-non-outputs:continue: +25645 # curr -= 12 +25646 81 5/subop/subtract %esi 0xc/imm32 +25647 e9/jump loop/disp32 +25648 } +25649 $emit-cleanup-code-for-non-outputs:end: +25650 # . restore registers +25651 5f/pop-to-edi +25652 5e/pop-to-esi +25653 5b/pop-to-ebx +25654 5a/pop-to-edx +25655 59/pop-to-ecx +25656 58/pop-to-eax +25657 # . epilogue +25658 89/<- %esp 5/r32/ebp +25659 5d/pop-to-ebp +25660 c3/return +25661 +25662 emit-push-register: # out: (addr buffered-file), reg: (addr array byte) +25663 # . prologue +25664 55/push-ebp +25665 89/<- %ebp 4/r32/esp +25666 # eax = reg +25667 8b/-> *(ebp+0xc) 0/r32/eax +25668 # var prefix/eax: byte = reg->data[0] +25669 8a/copy-byte *(eax+4) 0/r32/AL +25670 81 4/subop/and %eax 0xff/imm32 +25671 # if (prefix == 'x') push xmm register +25672 { +25673 3d/compare-eax-and 0x78/imm32/x +25674 0f 85/jump-if-!= break/disp32 +25675 # TODO validate register +25676 (emit-indent *(ebp+8) *Curr-block-depth) +25677 (write-buffered *(ebp+8) "81 5/subop/subtract %esp 4/imm32\n") +25678 (emit-indent *(ebp+8) *Curr-block-depth) +25679 (write-buffered *(ebp+8) "f3 0f 11/<- *esp ") +25680 # var prefix/eax: byte = reg->data[3] +25681 8b/-> *(ebp+0xc) 0/r32/eax +25682 8a/copy-byte *(eax+7) 0/r32/AL +25683 81 4/subop/and %eax 0xff/imm32 +25684 (write-byte-buffered *(ebp+8) %eax) +25685 (write-buffered *(ebp+8) "/x32\n") +25686 e9/jump $emit-push-register:end/disp32 25687 } -25688 $array-element-type-id:skip-array: -25689 # t = t->right -25690 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -25691 # if t == 0 abort -25692 3d/compare-eax-with 0/imm32 -25693 0f 84/jump-if-= $array-element-type-id:error2/disp32 -25694 # if t->is-atom? abort -25695 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -25696 0f 85/jump-if-!= $array-element-type-id:error2/disp32 -25697 # t = t->left -25698 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -25699 # if (!t->is-atom?) t = t->left # TODO: assumes array element size can be determined from just first word of array element type -25700 # if (t->is-atom == false) t = lookup(t->left) -25701 { -25702 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -25703 75/jump-if-!= break/disp8 -25704 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -25705 } -25706 # return t->value -25707 8b/-> *(eax+4) 0/r32/eax # Type-tree-value -25708 $array-element-type-id:end: -25709 # . epilogue -25710 89/<- %esp 5/r32/ebp -25711 5d/pop-to-ebp -25712 c3/return -25713 -25714 $array-element-type-id:error0: -25715 (write-buffered *(ebp+0xc) "array-element-type-id: var '") -25716 50/push-eax -25717 8b/-> *(ebp+8) 0/r32/eax -25718 (lookup *eax *(eax+4)) # Var-name Var-name => eax -25719 (write-buffered *(ebp+0xc) %eax) -25720 58/pop-to-eax -25721 (write-buffered *(ebp+0xc) "' has no type\n") -25722 (flush *(ebp+0xc)) -25723 (stop *(ebp+0x10) 1) -25724 # never gets here -25725 -25726 $array-element-type-id:error1: -25727 (write-buffered *(ebp+0xc) "array-element-type-id: var '") -25728 50/push-eax -25729 8b/-> *(ebp+8) 0/r32/eax -25730 (lookup *eax *(eax+4)) # Var-name Var-name => eax -25731 (write-buffered *(ebp+0xc) %eax) -25732 58/pop-to-eax -25733 (write-buffered *(ebp+0xc) "' has atomic type ") -25734 (write-int32-hex-buffered *(ebp+0xc) *(eax+4)) # Type-tree-value -25735 (write-buffered *(ebp+0xc) Newline) -25736 (flush *(ebp+0xc)) -25737 (stop *(ebp+0x10) 1) -25738 # never gets here +25688 # otherwise push gp register +25689 (emit-indent *(ebp+8) *Curr-block-depth) +25690 (write-buffered *(ebp+8) "ff 6/subop/push %") +25691 (write-buffered *(ebp+8) *(ebp+0xc)) +25692 (write-buffered *(ebp+8) Newline) +25693 $emit-push-register:end: +25694 # . epilogue +25695 89/<- %esp 5/r32/ebp +25696 5d/pop-to-ebp +25697 c3/return +25698 +25699 emit-pop-register: # out: (addr buffered-file), reg: (addr array byte) +25700 # . prologue +25701 55/push-ebp +25702 89/<- %ebp 4/r32/esp +25703 # . save registers +25704 50/push-eax +25705 # eax = reg +25706 8b/-> *(ebp+0xc) 0/r32/eax +25707 # var prefix/eax: byte = reg->data[0] +25708 8a/copy-byte *(eax+4) 0/r32/AL +25709 81 4/subop/and %eax 0xff/imm32 +25710 # if (prefix == 'x') pop to xmm register +25711 { +25712 3d/compare-eax-and 0x78/imm32/x +25713 0f 85/jump-if-!= break/disp32 +25714 # TODO validate register +25715 (emit-indent *(ebp+8) *Curr-block-depth) +25716 (write-buffered *(ebp+8) "f3 0f 10/-> *esp ") +25717 # var prefix/eax: byte = reg->data[3] +25718 8b/-> *(ebp+0xc) 0/r32/eax +25719 8a/copy-byte *(eax+7) 0/r32/AL +25720 81 4/subop/and %eax 0xff/imm32 +25721 (write-byte-buffered *(ebp+8) %eax) +25722 (write-buffered *(ebp+8) "/x32\n") +25723 (emit-indent *(ebp+8) *Curr-block-depth) +25724 (write-buffered *(ebp+8) "81 0/subop/add %esp 4/imm32\n") +25725 e9/jump $emit-pop-register:end/disp32 +25726 } +25727 # otherwise pop to gp register +25728 (emit-indent *(ebp+8) *Curr-block-depth) +25729 (write-buffered *(ebp+8) "8f 0/subop/pop %") +25730 (write-buffered *(ebp+8) *(ebp+0xc)) +25731 (write-buffered *(ebp+8) Newline) +25732 $emit-pop-register:end: +25733 # . restore registers +25734 58/pop-to-eax +25735 # . epilogue +25736 89/<- %esp 5/r32/ebp +25737 5d/pop-to-ebp +25738 c3/return 25739 -25740 $array-element-type-id:error2: -25741 (write-buffered *(ebp+0xc) "array-element-type-id: var '") -25742 50/push-eax -25743 8b/-> *(ebp+8) 0/r32/eax -25744 (lookup *eax *(eax+4)) # Var-name Var-name => eax -25745 (write-buffered *(ebp+0xc) %eax) -25746 58/pop-to-eax -25747 (write-buffered *(ebp+0xc) "' has non-array type\n") -25748 (flush *(ebp+0xc)) -25749 (stop *(ebp+0x10) 1) -25750 # never gets here -25751 -25752 size-of-type-id-as-array-element: # t: type-id -> result/eax: int -25753 # . prologue -25754 55/push-ebp -25755 89/<- %ebp 4/r32/esp -25756 # eax = t -25757 8b/-> *(ebp+8) 0/r32/eax -25758 # if t is 'byte', size is 1 -25759 3d/compare-eax-and 8/imm32/byte -25760 { -25761 75/jump-if-!= break/disp8 -25762 b8/copy-to-eax 1/imm32 -25763 eb/jump $size-of-type-id-as-array-element:end/disp8 -25764 } -25765 # otherwise proceed as usual -25766 (size-of-type-id %eax) # => eax -25767 $size-of-type-id-as-array-element:end: -25768 # . epilogue -25769 89/<- %esp 5/r32/ebp -25770 5d/pop-to-ebp -25771 c3/return -25772 -25773 emit-save-size-to: # out: (addr buffered-file), base: (addr var), outreg: (addr array byte) -25774 # . prologue -25775 55/push-ebp -25776 89/<- %ebp 4/r32/esp -25777 # . save registers -25778 50/push-eax -25779 53/push-ebx -25780 # ebx = base -25781 8b/-> *(ebp+0xc) 3/r32/ebx -25782 (emit-indent *(ebp+8) *Curr-block-depth) -25783 (write-buffered *(ebp+8) "8b/-> *") -25784 # if base is an (addr array ...) in a register -25785 { -25786 81 7/subop/compare *(ebx+0x18)) 0/imm32 # Var-register -25787 74/jump-if-= break/disp8 -25788 $emit-save-size-to:emit-base-from-register: -25789 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -25790 (write-buffered *(ebp+8) %eax) -25791 eb/jump $emit-save-size-to:emit-output/disp8 -25792 } -25793 # otherwise if base is an (array ...) on the stack -25794 { -25795 81 7/subop/compare *(ebx+0x14)) 0/imm32 # Var-offset -25796 74/jump-if-= break/disp8 -25797 $emit-save-size-to:emit-base-from-stack: -25798 (write-buffered *(ebp+8) "(ebp+") -25799 (write-int32-hex-buffered *(ebp+8) *(ebx+0x14)) # Var-offset -25800 (write-buffered *(ebp+8) ")") -25801 } -25802 $emit-save-size-to:emit-output: -25803 (write-buffered *(ebp+8) " ") -25804 (get Mu-registers *(ebp+0x10) 0xc "Mu-registers") # => eax -25805 (write-int32-hex-buffered *(ebp+8) *eax) -25806 (write-buffered *(ebp+8) "/r32\n") -25807 $emit-save-size-to:end: -25808 # . restore registers -25809 5b/pop-to-ebx -25810 58/pop-to-eax -25811 # . epilogue -25812 89/<- %esp 5/r32/ebp -25813 5d/pop-to-ebp -25814 c3/return -25815 -25816 emit-divide-by-shift-right: # out: (addr buffered-file), reg: (addr array byte), size: int -25817 # . prologue -25818 55/push-ebp -25819 89/<- %ebp 4/r32/esp -25820 # . save registers -25821 50/push-eax -25822 # -25823 (emit-indent *(ebp+8) *Curr-block-depth) -25824 (write-buffered *(ebp+8) "c1/shift 5/subop/>> %") -25825 (write-buffered *(ebp+8) *(ebp+0xc)) -25826 (write-buffered *(ebp+8) Space) -25827 (num-shift-rights *(ebp+0x10)) # => eax -25828 (write-int32-hex-buffered *(ebp+8) %eax) -25829 (write-buffered *(ebp+8) "/imm8\n") -25830 $emit-divide-by-shift-right:end: -25831 # . restore registers -25832 58/pop-to-eax -25833 # . epilogue -25834 89/<- %esp 5/r32/ebp -25835 5d/pop-to-ebp -25836 c3/return -25837 -25838 translate-mu-index-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -25839 # . prologue -25840 55/push-ebp -25841 89/<- %ebp 4/r32/esp -25842 # . save registers -25843 51/push-ecx -25844 # ecx = stmt -25845 8b/-> *(ebp+0xc) 1/r32/ecx -25846 # var base/ecx: (addr var) = stmt->inouts[0] -25847 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -25848 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -25849 89/<- %ecx 0/r32/eax -25850 # if (var->register) do one thing -25851 { -25852 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register -25853 74/jump-if-= break/disp8 -25854 # TODO: ensure there's no dereference -25855 (translate-mu-index-stmt-with-array-in-register *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -25856 eb/jump $translate-mu-index-stmt:end/disp8 -25857 } -25858 # if (var->offset) do a different thing -25859 { -25860 81 7/subop/compare *(ecx+0x14) 0/imm32 # Var-offset -25861 74/jump-if-= break/disp8 -25862 # TODO: ensure there's no dereference -25863 (translate-mu-index-stmt-with-array-on-stack *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) -25864 eb/jump $translate-mu-index-stmt:end/disp8 -25865 } -25866 $translate-mu-index-stmt:end: -25867 # . restore registers -25868 59/pop-to-ecx -25869 # . epilogue -25870 89/<- %esp 5/r32/ebp -25871 5d/pop-to-ebp -25872 c3/return -25873 -25874 $translate-mu-index-stmt-with-array:error1: -25875 (write-buffered *(ebp+0x10) "couldn't translate an index instruction. second (index) input must either lie in a register or be a literal\n") -25876 (flush *(ebp+0x10)) -25877 (stop *(ebp+0x14) 1) -25878 # never gets here -25879 -25880 $translate-mu-index-stmt-with-array:error2: -25881 (write-buffered *(ebp+0x10) "couldn't translate an index instruction. second (index) input when in a register must be an int or offset\n") -25882 (flush *(ebp+0x10)) -25883 (stop *(ebp+0x14) 1) -25884 # never gets here -25885 -25886 translate-mu-index-stmt-with-array-in-register: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -25887 # . prologue -25888 55/push-ebp -25889 89/<- %ebp 4/r32/esp -25890 # . save registers -25891 50/push-eax -25892 51/push-ecx -25893 52/push-edx -25894 53/push-ebx -25895 # -25896 (emit-indent *(ebp+8) *Curr-block-depth) -25897 (write-buffered *(ebp+8) "8d/copy-address *(") -25898 # TODO: ensure inouts[0] is in a register and not dereferenced -25899 $translate-mu-index-stmt-with-array-in-register:emit-base: -25900 # ecx = stmt -25901 8b/-> *(ebp+0xc) 1/r32/ecx -25902 # var base/ebx: (addr var) = inouts[0] -25903 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -25904 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -25905 89/<- %ebx 0/r32/eax -25906 # print base->register " + " -25907 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax -25908 (write-buffered *(ebp+8) %eax) -25909 (write-buffered *(ebp+8) " + ") -25910 # var index/edx: (addr var) = inouts[1] -25911 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -25912 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -25913 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -25914 89/<- %edx 0/r32/eax -25915 # if index->register -25916 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register -25917 { -25918 0f 84/jump-if-= break/disp32 -25919 $translate-mu-index-stmt-with-array-in-register:emit-register-index: -25920 # if index is an int -25921 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -25922 (is-simple-mu-type? %eax 1) # int => eax -25923 3d/compare-eax-and 0/imm32/false -25924 { -25925 0f 84/jump-if-= break/disp32 -25926 $translate-mu-index-stmt-with-array-in-register:emit-int-register-index: -25927 # print index->register "<<" log2(array-element-size(base)) " + 4) " -25928 # . index->register "<<" -25929 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -25930 (write-buffered *(ebp+8) %eax) -25931 (write-buffered *(ebp+8) "<<") -25932 # . log2(array-element-size(base->type)) -25933 # TODO: ensure size is a power of 2 -25934 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax -25935 (num-shift-rights %eax) # => eax -25936 (write-int32-hex-buffered *(ebp+8) %eax) -25937 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-register-index-done/disp32 -25938 } -25939 # if index->type is any other atom, abort -25940 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -25941 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -25942 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 -25943 # if index has type (offset ...) -25944 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -25945 (is-simple-mu-type? %eax 7) # => eax -25946 3d/compare-eax-and 0/imm32/false -25947 { -25948 0f 84/jump-if-= break/disp32 -25949 # print index->register -25950 $translate-mu-index-stmt-with-array-in-register:emit-offset-register-index: -25951 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -25952 (write-buffered *(ebp+8) %eax) -25953 } -25954 $translate-mu-index-stmt-with-array-in-register:emit-register-index-done: -25955 (write-buffered *(ebp+8) " + 4) ") -25956 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 -25957 } -25958 # otherwise if index is a literal -25959 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -25960 (is-simple-mu-type? %eax 0) # => eax -25961 3d/compare-eax-and 0/imm32/false -25962 { -25963 0f 84/jump-if-= break/disp32 -25964 $translate-mu-index-stmt-with-array-in-register:emit-literal-index: -25965 # var index-value/edx: int = parse-hex-int(index->name) -25966 (lookup *edx *(edx+4)) # Var-name Var-name => eax -25967 (parse-hex-int %eax) # => eax -25968 89/<- %edx 0/r32/eax -25969 # offset = idx-value * array-element-size(base->type) -25970 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax -25971 f7 4/subop/multiply-into-edx-eax %edx # clobbers edx -25972 # offset += 4 for array size -25973 05/add-to-eax 4/imm32 -25974 # TODO: check edx for overflow -25975 # print offset -25976 (write-int32-hex-buffered *(ebp+8) %eax) -25977 (write-buffered *(ebp+8) ") ") -25978 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 -25979 } -25980 # otherwise abort -25981 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 -25982 $translate-mu-index-stmt-with-array-in-register:emit-output: -25983 # outputs[0] "/r32" -25984 8b/-> *(ebp+0xc) 1/r32/ecx -25985 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -25986 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -25987 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -25988 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) -25989 (write-int32-hex-buffered *(ebp+8) *eax) -25990 (write-buffered *(ebp+8) "/r32\n") -25991 $translate-mu-index-stmt-with-array-in-register:end: -25992 # . restore registers -25993 5b/pop-to-ebx -25994 5a/pop-to-edx -25995 59/pop-to-ecx -25996 58/pop-to-eax -25997 # . epilogue -25998 89/<- %esp 5/r32/ebp -25999 5d/pop-to-ebp -26000 c3/return -26001 -26002 translate-mu-index-stmt-with-array-on-stack: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -26003 # . prologue -26004 55/push-ebp -26005 89/<- %ebp 4/r32/esp -26006 # . save registers -26007 50/push-eax -26008 51/push-ecx -26009 52/push-edx -26010 53/push-ebx -26011 # -26012 (emit-indent *(ebp+8) *Curr-block-depth) -26013 (write-buffered *(ebp+8) "8d/copy-address *(ebp + ") -26014 # var curr/edx: (addr stmt-var) = lookup(stmt->inouts) -26015 8b/-> *(ebp+0xc) 0/r32/eax -26016 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26017 89/<- %edx 0/r32/eax -26018 # var base/ecx: (addr var) = lookup(curr->value) -26019 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26020 89/<- %ecx 0/r32/eax -26021 # var curr2/eax: (addr stmt-var) = lookup(curr->next) -26022 (lookup *(edx+8) *(edx+0xc)) # Stmt-var-next Stmt-var-next => eax -26023 # var index/edx: (handle var) = curr2->value -26024 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26025 89/<- %edx 0/r32/eax -26026 # if index->register -26027 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register -26028 { -26029 0f 84/jump-if-= break/disp32 -26030 $translate-mu-index-stmt-with-array-on-stack:emit-register-index: -26031 # if index is an int -26032 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -26033 (is-simple-mu-type? %eax 1) # int => eax -26034 3d/compare-eax-and 0/imm32/false -26035 { -26036 0f 84/jump-if-= break/disp32 -26037 $translate-mu-index-stmt-with-array-on-stack:emit-int-register-index: -26038 # print index->register "<<" log2(array-element-size(base)) " + " base->offset+4 -26039 # . inouts[1]->register "<<" -26040 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -26041 (write-buffered *(ebp+8) %eax) -26042 (write-buffered *(ebp+8) "<<") -26043 # . log2(array-element-size(base)) -26044 # TODO: ensure size is a power of 2 -26045 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14)) # => eax -26046 (num-shift-rights %eax) # => eax -26047 (write-int32-hex-buffered *(ebp+8) %eax) -26048 # -26049 (write-buffered *(ebp+8) " + ") -26050 # -26051 8b/-> *(ecx+0x14) 0/r32/eax # Var-offset -26052 05/add-to-eax 4/imm32 # for array length -26053 (write-int32-hex-buffered *(ebp+8) %eax) -26054 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done/disp32 -26055 } -26056 # if index->type is any other atom, abort -26057 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -26058 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -26059 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 -26060 # if index has type (offset ...) -26061 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -26062 (is-simple-mu-type? %eax 7) # => eax -26063 3d/compare-eax-and 0/imm32/false -26064 { -26065 0f 84/jump-if-= break/disp32 -26066 # print index->register -26067 $translate-mu-index-stmt-with-array-on-stack:emit-offset-register-index: -26068 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax -26069 (write-buffered *(ebp+8) %eax) -26070 } -26071 $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done: -26072 (write-buffered *(ebp+8) ") ") -26073 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 -26074 } -26075 # otherwise if index is a literal -26076 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax -26077 (is-simple-mu-type? %eax 0) # => eax -26078 3d/compare-eax-and 0/imm32/false -26079 { -26080 0f 84/jump-if-= break/disp32 -26081 $translate-mu-index-stmt-with-array-on-stack:emit-literal-index: -26082 # var idx-value/edx: int = parse-hex-int(index->name) -26083 (lookup *edx *(edx+4)) # Var-name Var-name => eax -26084 (parse-hex-int %eax) # Var-name => eax -26085 89/<- %edx 0/r32/eax -26086 # offset = idx-value * array-element-size(base) -26087 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14)) # => eax -26088 f7 4/subop/multiply-into-edx-eax %edx # clobbers edx -26089 # offset += base->offset -26090 03/add *(ecx+0x14) 0/r32/eax # Var-offset -26091 # offset += 4 for array size -26092 05/add-to-eax 4/imm32 -26093 # TODO: check edx for overflow -26094 # print offset -26095 (write-int32-hex-buffered *(ebp+8) %eax) -26096 (write-buffered *(ebp+8) ") ") -26097 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 -26098 } -26099 # otherwise abort -26100 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 -26101 $translate-mu-index-stmt-with-array-on-stack:emit-output: -26102 # outputs[0] "/r32" -26103 8b/-> *(ebp+0xc) 0/r32/eax -26104 (lookup *(eax+0x14) *(eax+0x18)) # Stmt1-outputs Stmt1-outputs => eax -26105 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26106 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -26107 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) -26108 (write-int32-hex-buffered *(ebp+8) *eax) -26109 (write-buffered *(ebp+8) "/r32\n") -26110 $translate-mu-index-stmt-with-array-on-stack:end: -26111 # . restore registers -26112 5b/pop-to-ebx -26113 5a/pop-to-edx -26114 59/pop-to-ecx -26115 58/pop-to-eax -26116 # . epilogue -26117 89/<- %esp 5/r32/ebp -26118 5d/pop-to-ebp -26119 c3/return -26120 -26121 translate-mu-compute-index-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -26122 # . prologue -26123 55/push-ebp -26124 89/<- %ebp 4/r32/esp -26125 # . save registers -26126 50/push-eax -26127 51/push-ecx -26128 52/push-edx -26129 53/push-ebx -26130 # -26131 (emit-indent *(ebp+8) *Curr-block-depth) -26132 (write-buffered *(ebp+8) "69/multiply") -26133 # ecx = stmt -26134 8b/-> *(ebp+0xc) 1/r32/ecx -26135 # var first-inout/ebx: (addr stmt-var) = stmt->inouts[0] -26136 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26137 89/<- %ebx 0/r32/eax -26138 $translate-mu-compute-index-stmt:emit-index: -26139 (lookup *(ebx+8) *(ebx+0xc)) # Stmt-var-next Stmt-var-next => eax -26140 (emit-subx-var-as-rm32 *(ebp+8) %eax) -26141 (write-buffered *(ebp+8) Space) -26142 $translate-mu-compute-index-stmt:emit-elem-size: -26143 # var base/ebx: (addr var) -26144 (lookup *ebx *(ebx+4)) # Stmt-var-value Stmt-var-value => eax -26145 89/<- %ebx 0/r32/eax -26146 # print array-element-size(base) -26147 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax -26148 (write-int32-hex-buffered *(ebp+8) %eax) -26149 (write-buffered *(ebp+8) "/imm32 ") -26150 $translate-mu-compute-index-stmt:emit-output: -26151 # outputs[0] "/r32" -26152 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -26153 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26154 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -26155 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) -26156 (write-int32-hex-buffered *(ebp+8) *eax) -26157 (write-buffered *(ebp+8) "/r32\n") -26158 $translate-mu-compute-index-stmt:end: -26159 # . restore registers -26160 5b/pop-to-ebx -26161 5a/pop-to-edx -26162 59/pop-to-ecx -26163 58/pop-to-eax -26164 # . epilogue -26165 89/<- %esp 5/r32/ebp -26166 5d/pop-to-ebp -26167 c3/return -26168 -26169 translate-mu-get-stmt: # out: (addr buffered-file), stmt: (addr stmt) -26170 # . prologue -26171 55/push-ebp -26172 89/<- %ebp 4/r32/esp -26173 # . save registers -26174 50/push-eax -26175 51/push-ecx -26176 52/push-edx -26177 # -26178 (emit-indent *(ebp+8) *Curr-block-depth) -26179 (write-buffered *(ebp+8) "8d/copy-address ") -26180 # ecx = stmt -26181 8b/-> *(ebp+0xc) 1/r32/ecx -26182 # var offset/edx: int = get offset of stmt -26183 (mu-get-offset %ecx) # => eax -26184 89/<- %edx 0/r32/eax -26185 # var base/eax: (addr var) = stmt->inouts->value -26186 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26187 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26188 # if base is in a register -26189 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register -26190 { -26191 0f 84/jump-if-= break/disp32 -26192 $translate-mu-get-stmt:emit-register-input: -26193 # emit "*(" base->register " + " offset ") " -26194 (write-buffered *(ebp+8) "*(") -26195 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -26196 (write-buffered *(ebp+8) %eax) -26197 (write-buffered *(ebp+8) " + ") -26198 (write-int32-hex-buffered *(ebp+8) %edx) -26199 (write-buffered *(ebp+8) ") ") -26200 e9/jump $translate-mu-get-stmt:emit-output/disp32 -26201 } -26202 # otherwise base is on the stack -26203 { -26204 $translate-mu-get-stmt:emit-stack-input: -26205 # emit "*(ebp + " inouts[0]->stack-offset + offset ") " -26206 (write-buffered *(ebp+8) "*(ebp+") -26207 03/add *(eax+0x14) 2/r32/edx # Var-offset -26208 (write-int32-hex-buffered *(ebp+8) %edx) -26209 (write-buffered *(ebp+8) ") ") -26210 eb/jump $translate-mu-get-stmt:emit-output/disp8 -26211 } -26212 $translate-mu-get-stmt:emit-output: -26213 # var output/eax: (addr var) = stmt->outputs->value -26214 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -26215 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26216 # emit offset->register "/r32" -26217 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -26218 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) -26219 (write-int32-hex-buffered *(ebp+8) *eax) -26220 (write-buffered *(ebp+8) "/r32\n") -26221 $translate-mu-get-stmt:end: -26222 # . restore registers -26223 5a/pop-to-edx -26224 59/pop-to-ecx -26225 58/pop-to-eax -26226 # . epilogue -26227 89/<- %esp 5/r32/ebp -26228 5d/pop-to-ebp -26229 c3/return -26230 -26231 translate-mu-copy-object-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -26232 # . prologue -26233 55/push-ebp -26234 89/<- %ebp 4/r32/esp -26235 # . save registers -26236 50/push-eax -26237 # -26238 (emit-indent *(ebp+8) *Curr-block-depth) -26239 (write-buffered *(ebp+8) "(copy-bytes") -26240 # eax = stmt -26241 8b/-> *(ebp+0xc) 0/r32/eax -26242 # var first-inout/eax: (addr stmt-var) = stmt->inouts[0] -26243 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26244 (emit-subx-call-operand *(ebp+8) %eax) -26245 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -26246 (emit-subx-call-operand *(ebp+8) %eax) -26247 (write-buffered *(ebp+8) Space) -26248 (addr-payload-size %eax *(ebp+0x10) *(ebp+0x14)) # => eax -26249 (write-int32-hex-buffered *(ebp+8) %eax) -26250 (write-buffered *(ebp+8) ")\n") -26251 $translate-mu-copy-object-stmt:end: -26252 # . restore registers -26253 58/pop-to-eax -26254 # . epilogue -26255 89/<- %esp 5/r32/ebp -26256 5d/pop-to-ebp -26257 c3/return -26258 -26259 translate-mu-allocate-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -26260 # . prologue -26261 55/push-ebp -26262 89/<- %ebp 4/r32/esp -26263 # . save registers -26264 50/push-eax -26265 56/push-esi -26266 57/push-edi -26267 # esi = stmt -26268 8b/-> *(ebp+0xc) 6/r32/esi -26269 # var target/edi: (addr stmt-var) = stmt->inouts[0] -26270 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26271 89/<- %edi 0/r32/eax -26272 # -26273 (emit-indent *(ebp+8) *Curr-block-depth) -26274 (write-buffered *(ebp+8) "(allocate Heap ") -26275 (addr-handle-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -26276 (write-int32-hex-buffered *(ebp+8) %eax) -26277 (emit-subx-call-operand *(ebp+8) %edi) -26278 (write-buffered *(ebp+8) ")\n") -26279 $translate-mu-allocate-stmt:end: -26280 # . restore registers -26281 5f/pop-to-edi -26282 5e/pop-to-esi -26283 58/pop-to-eax -26284 # . epilogue -26285 89/<- %esp 5/r32/ebp -26286 5d/pop-to-ebp -26287 c3/return -26288 -26289 addr-handle-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -26290 # . prologue -26291 55/push-ebp -26292 89/<- %ebp 4/r32/esp -26293 # var t/eax: (addr type-tree) = s->value->type -26294 8b/-> *(ebp+8) 0/r32/eax -26295 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26296 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -26297 # TODO: check eax != 0 -26298 # TODO: check !t->is-atom? -26299 # TODO: check t->left == addr -26300 # t = t->right -26301 $addr-handle-payload-size:skip-addr: -26302 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -26303 # TODO: check eax != 0 -26304 # TODO: check !t->is-atom? -26305 # TODO: check t->left == handle -26306 # t = t->right -26307 $addr-handle-payload-size:skip-handle: -26308 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -26309 # TODO: check eax != 0 -26310 # if !t->is-atom? t = t->left -26311 81 7/subop/compare *eax 0/imm32/false -26312 { -26313 75/jump-if-!= break/disp8 -26314 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -26315 } -26316 # TODO: check t->is-atom? -26317 # return size(t->value) -26318 (size-of-type-id *(eax+4)) # Type-tree-value => eax -26319 $addr-handle-payload-size:end: -26320 # . epilogue -26321 89/<- %esp 5/r32/ebp -26322 5d/pop-to-ebp -26323 c3/return -26324 -26325 addr-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -26326 # . prologue -26327 55/push-ebp -26328 89/<- %ebp 4/r32/esp -26329 # var t/eax: (addr type-tree) = s->value->type -26330 8b/-> *(ebp+8) 0/r32/eax -26331 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26332 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -26333 # TODO: check eax != 0 -26334 # TODO: check !t->is-atom? -26335 # TODO: check t->left == addr -26336 # t = t->right -26337 $addr-payload-size:skip-addr: -26338 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -26339 # TODO: check eax != 0 -26340 # if !t->is-atom? t = t->left -26341 81 7/subop/compare *eax 0/imm32/false -26342 { -26343 75/jump-if-!= break/disp8 -26344 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -26345 } -26346 # TODO: check t->is-atom? -26347 # return size(t->value) -26348 (size-of-type-id *(eax+4)) # Type-tree-value => eax -26349 $addr-payload-size:end: -26350 # . epilogue -26351 89/<- %esp 5/r32/ebp -26352 5d/pop-to-ebp -26353 c3/return -26354 -26355 translate-mu-populate-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -26356 # . prologue -26357 55/push-ebp -26358 89/<- %ebp 4/r32/esp -26359 # . save registers -26360 50/push-eax -26361 51/push-ecx -26362 56/push-esi -26363 57/push-edi -26364 # esi = stmt -26365 8b/-> *(ebp+0xc) 6/r32/esi -26366 # var target/edi: (addr stmt-var) = stmt->inouts[0] -26367 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26368 89/<- %edi 0/r32/eax -26369 # var len/ecx: (addr stmt-var) = stmt->inouts[1] -26370 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -26371 89/<- %ecx 0/r32/eax -26372 # -26373 (emit-indent *(ebp+8) *Curr-block-depth) -26374 (write-buffered *(ebp+8) "(allocate-array2 Heap ") -26375 (addr-handle-array-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -26376 (write-int32-hex-buffered *(ebp+8) %eax) -26377 (emit-subx-call-operand *(ebp+8) %ecx) -26378 (emit-subx-call-operand *(ebp+8) %edi) -26379 (write-buffered *(ebp+8) ")\n") -26380 $translate-mu-populate-stmt:end: -26381 # . restore registers -26382 5f/pop-to-edi -26383 5e/pop-to-esi -26384 59/pop-to-ecx -26385 58/pop-to-eax -26386 # . epilogue -26387 89/<- %esp 5/r32/ebp -26388 5d/pop-to-ebp -26389 c3/return -26390 -26391 translate-mu-populate-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -26392 # . prologue -26393 55/push-ebp -26394 89/<- %ebp 4/r32/esp -26395 # . save registers -26396 50/push-eax -26397 51/push-ecx -26398 56/push-esi -26399 57/push-edi -26400 # esi = stmt -26401 8b/-> *(ebp+0xc) 6/r32/esi -26402 # var target/edi: (addr stmt-var) = stmt->inouts[0] -26403 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26404 89/<- %edi 0/r32/eax -26405 # var len/ecx: (addr stmt-var) = stmt->inouts[1] -26406 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax -26407 89/<- %ecx 0/r32/eax -26408 # -26409 (emit-indent *(ebp+8) *Curr-block-depth) -26410 (write-buffered *(ebp+8) "(new-stream Heap ") -26411 (addr-handle-stream-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -26412 (write-int32-hex-buffered *(ebp+8) %eax) -26413 (emit-subx-call-operand *(ebp+8) %ecx) -26414 (emit-subx-call-operand *(ebp+8) %edi) -26415 (write-buffered *(ebp+8) ")\n") -26416 $translate-mu-populate-stream-stmt:end: -26417 # . restore registers -26418 5f/pop-to-edi -26419 5e/pop-to-esi -26420 59/pop-to-ecx -26421 58/pop-to-eax -26422 # . epilogue -26423 89/<- %esp 5/r32/ebp -26424 5d/pop-to-ebp -26425 c3/return -26426 -26427 translate-mu-read-from-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -26428 # . prologue -26429 55/push-ebp -26430 89/<- %ebp 4/r32/esp -26431 # . save registers -26432 50/push-eax -26433 51/push-ecx -26434 56/push-esi -26435 57/push-edi -26436 # esi = stmt -26437 8b/-> *(ebp+0xc) 6/r32/esi -26438 # var stream/ecx: (addr stmt-var) = stmt->inouts[0] -26439 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26440 89/<- %ecx 0/r32/eax -26441 # var target/edi: (addr stmt-var) = stmt->inouts[1] -26442 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -26443 89/<- %edi 0/r32/eax -26444 # -26445 (emit-indent *(ebp+8) *Curr-block-depth) -26446 (write-buffered *(ebp+8) "(read-from-stream") -26447 (emit-subx-call-operand *(ebp+8) %ecx) -26448 (emit-subx-call-operand *(ebp+8) %edi) -26449 (write-buffered *(ebp+8) Space) -26450 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -26451 (write-int32-hex-buffered *(ebp+8) %eax) -26452 (write-buffered *(ebp+8) ")\n") -26453 $translate-mu-read-from-stream-stmt:end: -26454 # . restore registers -26455 5f/pop-to-edi -26456 5e/pop-to-esi -26457 59/pop-to-ecx -26458 58/pop-to-eax -26459 # . epilogue -26460 89/<- %esp 5/r32/ebp -26461 5d/pop-to-ebp -26462 c3/return -26463 -26464 translate-mu-write-to-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -26465 # . prologue -26466 55/push-ebp -26467 89/<- %ebp 4/r32/esp -26468 # . save registers -26469 50/push-eax -26470 51/push-ecx -26471 56/push-esi -26472 57/push-edi -26473 # esi = stmt -26474 8b/-> *(ebp+0xc) 6/r32/esi -26475 # var stream/ecx: (addr stmt-var) = stmt->inouts[0] -26476 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26477 89/<- %ecx 0/r32/eax -26478 # var target/edi: (addr stmt-var) = stmt->inouts[1] -26479 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax -26480 89/<- %edi 0/r32/eax -26481 # -26482 (emit-indent *(ebp+8) *Curr-block-depth) -26483 (write-buffered *(ebp+8) "(write-to-stream") -26484 (emit-subx-call-operand *(ebp+8) %ecx) -26485 (flush *(ebp+8)) -26486 (emit-subx-call-operand *(ebp+8) %edi) -26487 (flush *(ebp+8)) -26488 (write-buffered *(ebp+8) Space) -26489 (flush *(ebp+8)) -26490 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax -26491 (write-int32-hex-buffered *(ebp+8) %eax) -26492 (write-buffered *(ebp+8) ")\n") -26493 $translate-mu-write-to-stream-stmt:end: -26494 # . restore registers -26495 5f/pop-to-edi -26496 5e/pop-to-esi -26497 59/pop-to-ecx -26498 58/pop-to-eax -26499 # . epilogue -26500 89/<- %esp 5/r32/ebp -26501 5d/pop-to-ebp -26502 c3/return -26503 -26504 addr-handle-array-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -26505 # . prologue -26506 55/push-ebp -26507 89/<- %ebp 4/r32/esp -26508 # var t/eax: (addr type-tree) = s->value->type -26509 8b/-> *(ebp+8) 0/r32/eax -26510 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26511 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -26512 # TODO: check eax != 0 -26513 # TODO: check !t->is-atom? -26514 # TODO: check t->left == addr -26515 # t = t->right -26516 $addr-handle-array-payload-size:skip-addr: -26517 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -26518 # TODO: check eax != 0 -26519 # TODO: check !t->is-atom? -26520 # TODO: check t->left == handle -26521 # t = t->right -26522 $addr-handle-array-payload-size:skip-handle: -26523 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -26524 # TODO: check eax != 0 -26525 # TODO: check !t->is-atom? -26526 # TODO: check t->left == array -26527 # t = t->right -26528 $addr-handle-array-payload-size:skip-array: -26529 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -26530 # TODO: check eax != 0 -26531 # if !t->is-atom? t = t->left -26532 81 7/subop/compare *eax 0/imm32/false -26533 { -26534 75/jump-if-!= break/disp8 -26535 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -26536 } -26537 $addr-handle-array-payload-size:compute-size: -26538 # TODO: check t->is-atom? -26539 # return size(t->value) -26540 (size-of-type-id-as-array-element *(eax+4)) # Type-tree-value => eax -26541 $addr-handle-array-payload-size:end: -26542 # . epilogue -26543 89/<- %esp 5/r32/ebp -26544 5d/pop-to-ebp -26545 c3/return -26546 -26547 addr-handle-stream-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int -26548 # . prologue -26549 55/push-ebp -26550 89/<- %ebp 4/r32/esp -26551 # var t/eax: (addr type-tree) = s->value->type -26552 8b/-> *(ebp+8) 0/r32/eax -26553 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26554 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax -26555 # TODO: check eax != 0 -26556 # TODO: check !t->is-atom? -26557 # TODO: check t->left == addr -26558 # t = t->right -26559 $addr-handle-stream-payload-size:skip-addr: -26560 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -26561 # TODO: check eax != 0 -26562 # TODO: check !t->is-atom? -26563 # TODO: check t->left == handle -26564 # t = t->right -26565 $addr-handle-stream-payload-size:skip-handle: -26566 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -26567 # TODO: check eax != 0 -26568 # TODO: check !t->is-atom? -26569 # TODO: check t->left == stream -26570 # t = t->right -26571 $addr-handle-stream-payload-size:skip-stream: -26572 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -26573 # TODO: check eax != 0 -26574 # if !t->is-atom? t = t->left -26575 81 7/subop/compare *eax 0/imm32/false -26576 { -26577 75/jump-if-!= break/disp8 -26578 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +25740 # emit clean-up code for 'vars' until a given label is encountered +25741 # doesn't actually modify 'vars' so we need traverse manually inside the stack +25742 emit-cleanup-code-until-target: # out: (addr buffered-file), vars: (addr stack live-var), until-block-label: (addr array byte) +25743 # . prologue +25744 55/push-ebp +25745 89/<- %ebp 4/r32/esp +25746 # . save registers +25747 50/push-eax +25748 51/push-ecx +25749 52/push-edx +25750 53/push-ebx +25751 # ecx = vars +25752 8b/-> *(ebp+0xc) 1/r32/ecx +25753 # var eax: int = vars->top +25754 8b/-> *ecx 0/r32/eax +25755 # var curr/edx: (addr handle var) = &vars->data[vars->top - 12] +25756 8d/copy-address *(ecx+eax-4) 2/r32/edx # vars + 8 + vars->top - 12/Live-var-size +25757 # var min/ecx: (addr handle var) = vars->data +25758 81 0/subop/add %ecx 8/imm32 +25759 { +25760 $emit-cleanup-code-until-target:loop: +25761 # if (curr < min) break +25762 39/compare %edx 1/r32/ecx +25763 0f 82/jump-if-addr< break/disp32 +25764 # var v/ebx: (handle var) = lookup(*curr) +25765 (lookup *edx *(edx+4)) # => eax +25766 89/<- %ebx 0/r32/eax +25767 # if (v->name == until-block-label) break +25768 (lookup *ebx *(ebx+4)) # Var-name Var-name => eax +25769 (string-equal? %eax *(ebp+0x10)) # => eax +25770 3d/compare-eax-and 0/imm32/false +25771 0f 85/jump-if-!= break/disp32 +25772 # if v is in a register +25773 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register +25774 { +25775 0f 84/jump-if-= break/disp32 +25776 { +25777 $emit-cleanup-code-until-target:check-for-previous-spill: +25778 8b/-> *(edx+8) 0/r32/eax # Live-var-register-spilled +25779 3d/compare-eax-and 0/imm32/false +25780 74/jump-if-= break/disp8 +25781 $emit-cleanup-code-until-target:reclaim-var-in-register: +25782 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +25783 (emit-pop-register *(ebp+8) %eax) +25784 } +25785 eb/jump $emit-cleanup-code-until-target:continue/disp8 +25786 } +25787 # otherwise v is on the stack +25788 { +25789 75/jump-if-!= break/disp8 +25790 $emit-cleanup-code-until-target:reclaim-var-on-stack: +25791 (size-of %ebx) # => eax +25792 # don't emit code for labels +25793 3d/compare-eax-and 0/imm32 +25794 74/jump-if-= break/disp8 +25795 # +25796 (emit-indent *(ebp+8) *Curr-block-depth) +25797 (write-buffered *(ebp+8) "81 0/subop/add %esp ") +25798 (write-int32-hex-buffered *(ebp+8) %eax) +25799 (write-buffered *(ebp+8) "/imm32\n") +25800 } +25801 $emit-cleanup-code-until-target:continue: +25802 # curr -= 12 +25803 81 5/subop/subtract %edx 0xc/imm32 +25804 e9/jump loop/disp32 +25805 } +25806 $emit-cleanup-code-until-target:end: +25807 # . restore registers +25808 5b/pop-to-ebx +25809 5a/pop-to-edx +25810 59/pop-to-ecx +25811 58/pop-to-eax +25812 # . epilogue +25813 89/<- %esp 5/r32/ebp +25814 5d/pop-to-ebp +25815 c3/return +25816 +25817 # update Curr-local-stack-offset assuming vars until some block depth are popped +25818 # doesn't actually modify 'vars', so we need traverse manually inside the stack +25819 clean-up-stack-offset-state: # vars: (addr stack live-var), until-block-depth: int +25820 # . prologue +25821 55/push-ebp +25822 89/<- %ebp 4/r32/esp +25823 # . save registers +25824 50/push-eax +25825 51/push-ecx +25826 52/push-edx +25827 53/push-ebx +25828 56/push-esi +25829 # ecx = vars +25830 8b/-> *(ebp+8) 1/r32/ecx +25831 # var esi: int = vars->top +25832 8b/-> *ecx 6/r32/esi +25833 # var curr/esi: (addr handle var) = &vars->data[vars->top - 12] +25834 8d/copy-address *(ecx+esi-4) 6/r32/esi # vars + 8 + vars->top - 12/Live-var-size +25835 # var min/ecx: (addr handle var) = vars->data +25836 81 0/subop/add %ecx 8/imm32 +25837 # edx = until-block-depth +25838 8b/-> *(ebp+0xc) 2/r32/edx +25839 { +25840 $clean-up-stack-offset-state:loop: +25841 # if (curr < min) break +25842 39/compare %esi 1/r32/ecx +25843 0f 82/jump-if-addr< break/disp32 +25844 # var v/ebx: (addr var) = lookup(*curr) +25845 (lookup *esi *(esi+4)) # => eax +25846 89/<- %ebx 0/r32/eax +25847 # if (v->block-depth < until-block-depth) break +25848 39/compare *(ebx+0x10) 2/r32/edx # Var-block-depth +25849 0f 8c/jump-if-< break/disp32 +25850 # if v is in a register +25851 81 7/subop/compare *(ebx+0x18) 0/imm32 # Var-register +25852 { +25853 0f 84/jump-if-= break/disp32 +25854 { +25855 $clean-up-stack-offset-state:check-for-previous-spill: +25856 8b/-> *(esi+8) 0/r32/eax # Live-var-register-spilled +25857 3d/compare-eax-and 0/imm32/false +25858 74/jump-if-= break/disp8 +25859 $clean-up-stack-offset-state:reclaim-var-in-register: +25860 81 0/subop/add *Curr-local-stack-offset 4/imm32 +25861 } +25862 eb/jump $clean-up-stack-offset-state:continue/disp8 +25863 } +25864 # otherwise v is on the stack +25865 { +25866 75/jump-if-!= break/disp8 +25867 $clean-up-stack-offset-state:var-on-stack: +25868 (size-of %ebx) # => eax +25869 01/add-to *Curr-local-stack-offset 0/r32/eax +25870 } +25871 $clean-up-stack-offset-state:continue: +25872 # curr -= 12 +25873 81 5/subop/subtract %esi 0xc/imm32 +25874 e9/jump loop/disp32 +25875 } +25876 $clean-up-stack-offset-state:end: +25877 # . restore registers +25878 5e/pop-to-esi +25879 5b/pop-to-ebx +25880 5a/pop-to-edx +25881 59/pop-to-ecx +25882 58/pop-to-eax +25883 # . epilogue +25884 89/<- %esp 5/r32/ebp +25885 5d/pop-to-ebp +25886 c3/return +25887 +25888 # Return true if there isn't a variable in 'vars' with the same block-depth +25889 # and register as 'v'. +25890 # 'v' is guaranteed not to be within 'vars'. +25891 not-yet-spilled-this-block?: # v: (addr var), vars: (addr stack live-var) -> result/eax: boolean +25892 # . prologue +25893 55/push-ebp +25894 89/<- %ebp 4/r32/esp +25895 # . save registers +25896 51/push-ecx +25897 52/push-edx +25898 53/push-ebx +25899 56/push-esi +25900 57/push-edi +25901 # ecx = vars +25902 8b/-> *(ebp+0xc) 1/r32/ecx +25903 # var eax: int = vars->top +25904 8b/-> *ecx 0/r32/eax +25905 # var curr/edx: (addr handle var) = &vars->data[vars->top - 12] +25906 8d/copy-address *(ecx+eax-4) 2/r32/edx # vars + 8 + vars->top - 12/Live-var-size +25907 # var min/ecx: (addr handle var) = vars->data +25908 8d/copy-address *(ecx+8) 1/r32/ecx +25909 # var depth/ebx: int = v->block-depth +25910 8b/-> *(ebp+8) 3/r32/ebx +25911 8b/-> *(ebx+0x10) 3/r32/ebx # Var-block-depth +25912 # var needle/esi: (addr array byte) = v->register +25913 8b/-> *(ebp+8) 6/r32/esi +25914 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +25915 89/<- %esi 0/r32/eax +25916 { +25917 $not-yet-spilled-this-block?:loop: +25918 # if (curr < min) break +25919 39/compare %edx 1/r32/ecx +25920 0f 82/jump-if-addr< break/disp32 +25921 # var cand/edi: (addr var) = lookup(*curr) +25922 (lookup *edx *(edx+4)) # => eax +25923 89/<- %edi 0/r32/eax +25924 # if (cand->block-depth < depth) break +25925 39/compare *(edi+0x10) 3/r32/ebx # Var-block-depth +25926 0f 8c/jump-if-< break/disp32 +25927 # var cand-reg/edi: (array array byte) = cand->reg +25928 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax +25929 89/<- %edi 0/r32/eax +25930 # if (cand-reg == null) continue +25931 { +25932 $not-yet-spilled-this-block?:check-reg: +25933 81 7/subop/compare %edi 0/imm32 +25934 0f 84/jump-if-= break/disp32 +25935 # if (cand-reg == needle) return true +25936 (string-equal? %esi %edi) # => eax +25937 3d/compare-eax-and 0/imm32/false +25938 74/jump-if-= break/disp8 +25939 $not-yet-spilled-this-block?:return-false: +25940 b8/copy-to-eax 0/imm32/false +25941 eb/jump $not-yet-spilled-this-block?:end/disp8 +25942 } +25943 $not-yet-spilled-this-block?:continue: +25944 # curr -= 12 +25945 81 5/subop/subtract %edx 0xc/imm32 +25946 e9/jump loop/disp32 +25947 } +25948 $not-yet-spilled-this-block?:return-true: +25949 # return true +25950 b8/copy-to-eax 1/imm32/true +25951 $not-yet-spilled-this-block?:end: +25952 # . restore registers +25953 5f/pop-to-edi +25954 5e/pop-to-esi +25955 5b/pop-to-ebx +25956 5a/pop-to-edx +25957 59/pop-to-ecx +25958 # . epilogue +25959 89/<- %esp 5/r32/ebp +25960 5d/pop-to-ebp +25961 c3/return +25962 +25963 # could the register of 'v' ever be written to by one of the vars in fn-outputs? +25964 will-not-write-some-register?: # v: (addr var), stmts: (addr list stmt), fn: (addr function) -> result/eax: boolean +25965 # . prologue +25966 55/push-ebp +25967 89/<- %ebp 4/r32/esp +25968 # eax = v +25969 8b/-> *(ebp+8) 0/r32/eax +25970 # var reg/eax: (addr array byte) = lookup(v->register) +25971 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +25972 # var target/eax: (addr var) = find-register(fn-outputs, reg) +25973 (find-register *(ebp+0x10) %eax) # => eax +25974 # if (target == 0) return true +25975 { +25976 3d/compare-eax-and 0/imm32 +25977 75/jump-if-!= break/disp8 +25978 b8/copy-to-eax 1/imm32/true +25979 eb/jump $will-not-write-some-register?:end/disp8 +25980 } +25981 # return !assigns-in-stmts?(stmts, target) +25982 (assigns-in-stmts? *(ebp+0xc) %eax) # => eax +25983 3d/compare-eax-and 0/imm32/false +25984 # assume: true = 1, so no need to mask with 0x000000ff +25985 0f 94/set-if-= %al +25986 $will-not-write-some-register?:end: +25987 # . epilogue +25988 89/<- %esp 5/r32/ebp +25989 5d/pop-to-ebp +25990 c3/return +25991 +25992 # return fn output with matching register +25993 # always returns false if 'reg' is null +25994 find-register: # fn: (addr function), reg: (addr array byte) -> result/eax: (addr var) +25995 # . prologue +25996 55/push-ebp +25997 89/<- %ebp 4/r32/esp +25998 # . save registers +25999 51/push-ecx +26000 # var curr/ecx: (addr list var) = lookup(fn->outputs) +26001 8b/-> *(ebp+8) 1/r32/ecx +26002 (lookup *(ecx+0x10) *(ecx+0x14)) # Function-outputs Function-outputs => eax +26003 89/<- %ecx 0/r32/eax +26004 { +26005 $find-register:loop: +26006 # if (curr == 0) break +26007 81 7/subop/compare %ecx 0/imm32 +26008 74/jump-if-= break/disp8 +26009 # eax = curr->value->register +26010 (lookup *ecx *(ecx+4)) # List-value List-value => eax +26011 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +26012 # if (eax == reg) return curr->value +26013 $find-register:compare: +26014 (string-equal? *(ebp+0xc) %eax) # => eax +26015 { +26016 3d/compare-eax-and 0/imm32/false +26017 74/jump-if-= break/disp8 +26018 $find-register:found: +26019 (lookup *ecx *(ecx+4)) # List-value List-value => eax +26020 eb/jump $find-register:end/disp8 +26021 } +26022 # curr = lookup(curr->next) +26023 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +26024 89/<- %ecx 0/r32/eax +26025 # +26026 eb/jump loop/disp8 +26027 } +26028 $find-register:end: +26029 # . restore registers +26030 59/pop-to-ecx +26031 # . epilogue +26032 89/<- %esp 5/r32/ebp +26033 5d/pop-to-ebp +26034 c3/return +26035 +26036 assigns-in-stmts?: # stmts: (addr list stmt), v: (addr var) -> result/eax: boolean +26037 # . prologue +26038 55/push-ebp +26039 89/<- %ebp 4/r32/esp +26040 # . save registers +26041 51/push-ecx +26042 # var curr/ecx: (addr list stmt) = stmts +26043 8b/-> *(ebp+8) 1/r32/ecx +26044 { +26045 # if (curr == 0) break +26046 81 7/subop/compare %ecx 0/imm32 +26047 74/jump-if-= break/disp8 +26048 # if assigns-in-stmt?(curr->value, v) return true +26049 (lookup *ecx *(ecx+4)) # List-value List-value => eax +26050 (assigns-in-stmt? %eax *(ebp+0xc)) # => eax +26051 3d/compare-eax-and 0/imm32/false +26052 75/jump-if-!= break/disp8 +26053 # curr = lookup(curr->next) +26054 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +26055 89/<- %ecx 0/r32/eax +26056 # +26057 eb/jump loop/disp8 +26058 } +26059 $assigns-in-stmts?:end: +26060 # . restore registers +26061 59/pop-to-ecx +26062 # . epilogue +26063 89/<- %esp 5/r32/ebp +26064 5d/pop-to-ebp +26065 c3/return +26066 +26067 assigns-in-stmt?: # stmt: (addr stmt), v: (addr var) -> result/eax: boolean +26068 # . prologue +26069 55/push-ebp +26070 89/<- %ebp 4/r32/esp +26071 # . save registers +26072 51/push-ecx +26073 # ecx = stmt +26074 8b/-> *(ebp+8) 1/r32/ecx +26075 # if stmt is a stmt1, return assigns-in-stmt-vars?(stmt->outputs, v) +26076 { +26077 81 7/subop/compare *ecx 1/imm32/stmt1 # Stmt-tag +26078 75/jump-if-!= break/disp8 +26079 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +26080 (assigns-in-stmt-vars? %eax *(ebp+0xc)) # => eax +26081 eb/jump $assigns-in-stmt?:end/disp8 +26082 } +26083 # if stmt is a block, return assigns-in-stmts?(stmt->stmts, v) +26084 { +26085 81 7/subop/compare *ecx 0/imm32/block # Stmt-tag +26086 75/jump-if-!= break/disp8 +26087 (lookup *(ecx+4) *(ecx+8)) # Block-stmts Block-stmts => eax +26088 (assigns-in-stmts? %eax *(ebp+0xc)) # => eax +26089 eb/jump $assigns-in-stmt?:end/disp8 +26090 } +26091 # otherwise return false +26092 b8/copy 0/imm32/false +26093 $assigns-in-stmt?:end: +26094 # . restore registers +26095 59/pop-to-ecx +26096 # . epilogue +26097 89/<- %esp 5/r32/ebp +26098 5d/pop-to-ebp +26099 c3/return +26100 +26101 assigns-in-stmt-vars?: # stmt-var: (addr stmt-var), v: (addr var) -> result/eax: boolean +26102 # . prologue +26103 55/push-ebp +26104 89/<- %ebp 4/r32/esp +26105 # . save registers +26106 51/push-ecx +26107 # var curr/ecx: (addr stmt-var) = stmt-var +26108 8b/-> *(ebp+8) 1/r32/ecx +26109 { +26110 # if (curr == 0) break +26111 81 7/subop/compare %ecx 0/imm32 +26112 74/jump-if-= break/disp8 +26113 # eax = lookup(curr->value) +26114 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +26115 # if (eax == v && curr->is-deref? == false) return true +26116 { +26117 39/compare *(ebp+0xc) 0/r32/eax +26118 75/jump-if-!= break/disp8 +26119 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +26120 75/jump-if-!= break/disp8 +26121 b8/copy-to-eax 1/imm32/true +26122 eb/jump $assigns-in-stmt-vars?:end/disp8 +26123 } +26124 # curr = lookup(curr->next) +26125 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +26126 89/<- %ecx 0/r32/eax +26127 # +26128 eb/jump loop/disp8 +26129 } +26130 $assigns-in-stmt-vars?:end: +26131 # . restore registers +26132 59/pop-to-ecx +26133 # . epilogue +26134 89/<- %esp 5/r32/ebp +26135 5d/pop-to-ebp +26136 c3/return +26137 +26138 # is there a var before 'v' with the same block-depth and register on the 'vars' stack? +26139 # v is guaranteed to be within vars +26140 # 'start' is provided as an optimization, a pointer within vars +26141 # *start == v +26142 same-register-spilled-before?: # v: (addr var), vars: (addr stack (handle var)), start: (addr var) -> result/eax: boolean +26143 # . prologue +26144 55/push-ebp +26145 89/<- %ebp 4/r32/esp +26146 # . save registers +26147 51/push-ecx +26148 52/push-edx +26149 53/push-ebx +26150 56/push-esi +26151 57/push-edi +26152 # ecx = v +26153 8b/-> *(ebp+8) 1/r32/ecx +26154 # var reg/edx: (addr array byte) = lookup(v->register) +26155 (lookup *(ecx+0x18) *(ecx+0x1c)) # Var-register Var-register => eax +26156 89/<- %edx 0/r32/eax +26157 # var depth/ebx: int = v->block-depth +26158 8b/-> *(ecx+0x10) 3/r32/ebx # Var-block-depth +26159 # var min/ecx: (addr handle var) = vars->data +26160 8b/-> *(ebp+0xc) 1/r32/ecx +26161 81 0/subop/add %ecx 8/imm32 +26162 # TODO: check that start >= min and start < &vars->data[top] +26163 # TODO: check that *start == v +26164 # var curr/esi: (addr handle var) = start +26165 8b/-> *(ebp+0x10) 6/r32/esi +26166 # curr -= 8 +26167 81 5/subop/subtract %esi 8/imm32 +26168 { +26169 $same-register-spilled-before?:loop: +26170 # if (curr < min) break +26171 39/compare %esi 1/r32/ecx +26172 0f 82/jump-if-addr< break/disp32 +26173 # var x/eax: (addr var) = lookup(*curr) +26174 (lookup *esi *(esi+4)) # => eax +26175 # if (x->block-depth < depth) break +26176 39/compare *(eax+0x10) 3/r32/ebx # Var-block-depth +26177 0f 8c/jump-if-< break/disp32 +26178 # if (x->register == 0) continue +26179 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +26180 74/jump-if-= $same-register-spilled-before?:continue/disp8 +26181 # if (x->register == reg) return true +26182 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +26183 (string-equal? %eax %edx) # => eax +26184 3d/compare-eax-and 0/imm32/false +26185 b8/copy-to-eax 1/imm32/true +26186 75/jump-if-!= $same-register-spilled-before?:end/disp8 +26187 $same-register-spilled-before?:continue: +26188 # curr -= 8 +26189 81 5/subop/subtract %esi 8/imm32 +26190 e9/jump loop/disp32 +26191 } +26192 $same-register-spilled-before?:false: +26193 b8/copy-to-eax 0/imm32/false +26194 $same-register-spilled-before?:end: +26195 # . restore registers +26196 5f/pop-to-edi +26197 5e/pop-to-esi +26198 5b/pop-to-ebx +26199 5a/pop-to-edx +26200 59/pop-to-ecx +26201 # . epilogue +26202 89/<- %esp 5/r32/ebp +26203 5d/pop-to-ebp +26204 c3/return +26205 +26206 # clean up global state for 'vars' until some block depth (inclusive) +26207 clean-up-blocks: # vars: (addr stack live-var), until-block-depth: int, fn: (addr function) +26208 # . prologue +26209 55/push-ebp +26210 89/<- %ebp 4/r32/esp +26211 # . save registers +26212 50/push-eax +26213 51/push-ecx +26214 56/push-esi +26215 # esi = vars +26216 8b/-> *(ebp+8) 6/r32/esi +26217 # ecx = until-block-depth +26218 8b/-> *(ebp+0xc) 1/r32/ecx +26219 { +26220 $clean-up-blocks:reclaim-loop: +26221 # if (vars->top <= 0) break +26222 8b/-> *esi 0/r32/eax # Stack-top +26223 3d/compare-eax-and 0/imm32 +26224 0f 8e/jump-if-<= break/disp32 +26225 # var v/eax: (addr var) = lookup(vars[vars->top-12]) +26226 (lookup *(esi+eax-4) *(esi+eax)) # vars + 8 + vars->top - 12 => eax +26227 # if (v->block-depth < until-block-depth) break +26228 39/compare *(eax+0x10) 1/r32/ecx # Var-block-depth +26229 0f 8c/jump-if-< break/disp32 +26230 (pop %esi) # => eax +26231 (pop %esi) # => eax +26232 (pop %esi) # => eax +26233 e9/jump loop/disp32 +26234 } +26235 $clean-up-blocks:end: +26236 # . restore registers +26237 5e/pop-to-esi +26238 59/pop-to-ecx +26239 58/pop-to-eax +26240 # . epilogue +26241 89/<- %esp 5/r32/ebp +26242 5d/pop-to-ebp +26243 c3/return +26244 +26245 reg-in-function-outputs?: # fn: (addr function), target: (addr array byte) -> result/eax: boolean +26246 # . prologue +26247 55/push-ebp +26248 89/<- %ebp 4/r32/esp +26249 # . save registers +26250 51/push-ecx +26251 # var curr/ecx: (addr list var) = lookup(fn->outputs) +26252 8b/-> *(ebp+8) 0/r32/eax +26253 (lookup *(eax+0x10) *(eax+0x14)) # Function-outputs Function-outputs => eax +26254 89/<- %ecx 0/r32/eax +26255 # while curr != null +26256 { +26257 81 7/subop/compare %ecx 0/imm32 +26258 74/jump-if-= break/disp8 +26259 # var v/eax: (addr var) = lookup(curr->value) +26260 (lookup *ecx *(ecx+4)) # List-value List-value => eax +26261 # var reg/eax: (addr array byte) = lookup(v->register) +26262 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +26263 # if (reg == target) return true +26264 (string-equal? %eax *(ebp+0xc)) # => eax +26265 3d/compare-eax-and 0/imm32/false +26266 75/jump-if-!= $reg-in-function-outputs?:end/disp8 +26267 # curr = curr->next +26268 (lookup *(ecx+8) *(ecx+0xc)) # List-next List-next => eax +26269 89/<- %ecx 0/r32/eax +26270 # +26271 eb/jump loop/disp8 +26272 } +26273 # return false +26274 b8/copy-to-eax 0/imm32 +26275 $reg-in-function-outputs?:end: +26276 # . restore registers +26277 59/pop-to-ecx +26278 # . epilogue +26279 89/<- %esp 5/r32/ebp +26280 5d/pop-to-ebp +26281 c3/return +26282 +26283 emit-subx-var-def: # out: (addr buffered-file), stmt: (addr stmt) +26284 # . prologue +26285 55/push-ebp +26286 89/<- %ebp 4/r32/esp +26287 # . save registers +26288 50/push-eax +26289 51/push-ecx +26290 52/push-edx +26291 # eax = stmt +26292 8b/-> *(ebp+0xc) 0/r32/eax +26293 # var v/ecx: (addr var) +26294 (lookup *(eax+4) *(eax+8)) # Vardef-var Vardef-var => eax +26295 89/<- %ecx 0/r32/eax +26296 # v->block-depth = *Curr-block-depth +26297 8b/-> *Curr-block-depth 0/r32/eax +26298 89/<- *(ecx+0x10) 0/r32/eax # Var-block-depth +26299 # var n/edx: int = size-of(stmt->var) +26300 (size-of %ecx) # => eax +26301 89/<- %edx 0/r32/eax +26302 # *Curr-local-stack-offset -= n +26303 29/subtract-from *Curr-local-stack-offset 2/r32/edx +26304 # v->offset = *Curr-local-stack-offset +26305 8b/-> *Curr-local-stack-offset 0/r32/eax +26306 89/<- *(ecx+0x14) 0/r32/eax # Var-offset +26307 # if v is an array, do something special to initialize it +26308 { +26309 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +26310 (is-mu-array? %eax) # => eax +26311 3d/compare-eax-and 0/imm32/false +26312 0f 84/jump-if-= break/disp32 +26313 # var array-size-without-size/edx: int = n-4 +26314 81 5/subop/subtract %edx 4/imm32 +26315 # +26316 (emit-array-data-initialization *(ebp+8) %edx) +26317 e9/jump $emit-subx-var-def:end/disp32 +26318 } +26319 # another special-case for initializing streams +26320 # a stream is an array with 2 extra pointers +26321 { +26322 (lookup *(ecx+8) *(ecx+0xc)) # Var-type Var-type => eax +26323 (is-mu-stream? %eax) # => eax +26324 3d/compare-eax-and 0/imm32/false +26325 0f 84/jump-if-= break/disp32 +26326 # var array-size-without-size/edx: int = n-12 +26327 81 5/subop/subtract %edx 0xc/imm32 +26328 (emit-array-data-initialization *(ebp+8) %edx) +26329 # emit read and write pointers +26330 (emit-indent *(ebp+8) *Curr-block-depth) +26331 (write-buffered *(ebp+8) "68/push 0/imm32\n") +26332 (emit-indent *(ebp+8) *Curr-block-depth) +26333 (write-buffered *(ebp+8) "68/push 0/imm32\n") +26334 # +26335 eb/jump $emit-subx-var-def:end/disp8 +26336 } +26337 # while n > 0 +26338 { +26339 81 7/subop/compare %edx 0/imm32 +26340 7e/jump-if-<= break/disp8 +26341 (emit-indent *(ebp+8) *Curr-block-depth) +26342 (write-buffered *(ebp+8) "68/push 0/imm32\n") +26343 # n -= 4 +26344 81 5/subop/subtract %edx 4/imm32 +26345 # +26346 eb/jump loop/disp8 +26347 } +26348 $emit-subx-var-def:end: +26349 # . restore registers +26350 5a/pop-to-edx +26351 59/pop-to-ecx +26352 58/pop-to-eax +26353 # . epilogue +26354 89/<- %esp 5/r32/ebp +26355 5d/pop-to-ebp +26356 c3/return +26357 +26358 emit-array-data-initialization: # out: (addr buffered-file), n: int +26359 # . prologue +26360 55/push-ebp +26361 89/<- %ebp 4/r32/esp +26362 # +26363 (emit-indent *(ebp+8) *Curr-block-depth) +26364 (write-buffered *(ebp+8) "(push-n-zero-bytes ") +26365 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc)) +26366 (write-buffered *(ebp+8) ")\n") +26367 (emit-indent *(ebp+8) *Curr-block-depth) +26368 (write-buffered *(ebp+8) "68/push ") +26369 (write-int32-hex-buffered *(ebp+8) *(ebp+0xc)) +26370 (write-buffered *(ebp+8) "/imm32\n") +26371 $emit-array-data-initialization:end: +26372 # . epilogue +26373 89/<- %esp 5/r32/ebp +26374 5d/pop-to-ebp +26375 c3/return +26376 +26377 emit-subx-stmt: # out: (addr buffered-file), stmt: (addr stmt), primitives: (addr primitive), err: (addr buffered-file), ed: (addr exit-descriptor) +26378 # . prologue +26379 55/push-ebp +26380 89/<- %ebp 4/r32/esp +26381 # . save registers +26382 50/push-eax +26383 51/push-ecx +26384 # - some special-case primitives that don't actually use the 'primitives' data structure +26385 # var op/ecx: (addr array byte) = lookup(stmt->operation) +26386 8b/-> *(ebp+0xc) 1/r32/ecx +26387 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +26388 89/<- %ecx 0/r32/eax +26389 # array size +26390 { +26391 # if (!string-equal?(stmt->operation, "length")) break +26392 (string-equal? %ecx "length") # => eax +26393 3d/compare-eax-and 0/imm32 +26394 0f 84/jump-if-= break/disp32 +26395 (translate-mu-length-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26396 e9/jump $emit-subx-stmt:end/disp32 +26397 } +26398 # index into array +26399 { +26400 # if (!string-equal?(stmt->operation, "index")) break +26401 (string-equal? %ecx "index") # => eax +26402 3d/compare-eax-and 0/imm32 +26403 0f 84/jump-if-= break/disp32 +26404 (translate-mu-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26405 e9/jump $emit-subx-stmt:end/disp32 +26406 } +26407 # compute-offset for index into array +26408 { +26409 # if (!string-equal?(stmt->operation, "compute-offset")) break +26410 (string-equal? %ecx "compute-offset") # => eax +26411 3d/compare-eax-and 0/imm32 +26412 0f 84/jump-if-= break/disp32 +26413 (translate-mu-compute-index-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26414 e9/jump $emit-subx-stmt:end/disp32 +26415 } +26416 # get field from record +26417 { +26418 # if (!string-equal?(stmt->operation, "get")) break +26419 (string-equal? %ecx "get") # => eax +26420 3d/compare-eax-and 0/imm32 +26421 0f 84/jump-if-= break/disp32 +26422 (translate-mu-get-stmt *(ebp+8) *(ebp+0xc)) +26423 e9/jump $emit-subx-stmt:end/disp32 +26424 } +26425 # allocate scalar +26426 { +26427 # if (!string-equal?(stmt->operation, "allocate")) break +26428 (string-equal? %ecx "allocate") # => eax +26429 3d/compare-eax-and 0/imm32 +26430 0f 84/jump-if-= break/disp32 +26431 (translate-mu-allocate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26432 e9/jump $emit-subx-stmt:end/disp32 +26433 } +26434 # copy-object +26435 { +26436 # if (!string-equal?(stmt->operation, "copy-object")) break +26437 (string-equal? %ecx "copy-object") # => eax +26438 3d/compare-eax-and 0/imm32 +26439 0f 84/jump-if-= break/disp32 +26440 (translate-mu-copy-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26441 e9/jump $emit-subx-stmt:end/disp32 +26442 } +26443 # clear-object +26444 { +26445 # if (!string-equal?(stmt->operation, "clear-object")) break +26446 (string-equal? %ecx "clear-object") # => eax +26447 3d/compare-eax-and 0/imm32 +26448 0f 84/jump-if-= break/disp32 +26449 (translate-mu-clear-object-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26450 e9/jump $emit-subx-stmt:end/disp32 +26451 } +26452 # allocate array +26453 { +26454 # if (!string-equal?(stmt->operation, "populate")) break +26455 (string-equal? %ecx "populate") # => eax +26456 3d/compare-eax-and 0/imm32 +26457 0f 84/jump-if-= break/disp32 +26458 (translate-mu-populate-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26459 e9/jump $emit-subx-stmt:end/disp32 +26460 } +26461 # allocate stream +26462 { +26463 # if (!string-equal?(stmt->operation, "populate-stream")) break +26464 (string-equal? %ecx "populate-stream") # => eax +26465 3d/compare-eax-and 0/imm32 +26466 0f 84/jump-if-= break/disp32 +26467 (translate-mu-populate-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26468 e9/jump $emit-subx-stmt:end/disp32 +26469 } +26470 # read from stream +26471 { +26472 # if (!string-equal?(stmt->operation, "read-from-stream")) break +26473 (string-equal? %ecx "read-from-stream") # => eax +26474 3d/compare-eax-and 0/imm32 +26475 0f 84/jump-if-= break/disp32 +26476 (translate-mu-read-from-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26477 e9/jump $emit-subx-stmt:end/disp32 +26478 } +26479 # write to stream +26480 { +26481 # if (!string-equal?(stmt->operation, "write-to-stream")) break +26482 (string-equal? %ecx "write-to-stream") # => eax +26483 3d/compare-eax-and 0/imm32 +26484 0f 84/jump-if-= break/disp32 +26485 (translate-mu-write-to-stream-stmt *(ebp+8) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) +26486 e9/jump $emit-subx-stmt:end/disp32 +26487 } +26488 # - if stmt matches a primitive, emit it +26489 { +26490 $emit-subx-stmt:check-for-primitive: +26491 # var curr/eax: (addr primitive) +26492 (find-matching-primitive *(ebp+0x10) *(ebp+0xc)) # primitives, stmt => eax +26493 3d/compare-eax-and 0/imm32 +26494 74/jump-if-= break/disp8 +26495 $emit-subx-stmt:primitive: +26496 (emit-subx-primitive *(ebp+8) *(ebp+0xc) %eax) # out, stmt, curr +26497 e9/jump $emit-subx-stmt:end/disp32 +26498 } +26499 # - otherwise emit a call +26500 # TODO: type-checking +26501 $emit-subx-stmt:call: +26502 (emit-call *(ebp+8) *(ebp+0xc)) +26503 $emit-subx-stmt:end: +26504 # . restore registers +26505 59/pop-to-ecx +26506 58/pop-to-eax +26507 # . epilogue +26508 89/<- %esp 5/r32/ebp +26509 5d/pop-to-ebp +26510 c3/return +26511 +26512 translate-mu-length-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +26513 # . prologue +26514 55/push-ebp +26515 89/<- %ebp 4/r32/esp +26516 # . save registers +26517 50/push-eax +26518 51/push-ecx +26519 52/push-edx +26520 53/push-ebx +26521 56/push-esi +26522 # esi = stmt +26523 8b/-> *(ebp+0xc) 6/r32/esi +26524 # var base/ebx: (addr var) = stmt->inouts[0]->value +26525 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +26526 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +26527 89/<- %ebx 0/r32/eax +26528 # var elemsize/ecx: int = array-element-size(base) +26529 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax +26530 89/<- %ecx 0/r32/eax +26531 # var outreg/edx: (addr array byte) = stmt->outputs[0]->value->register +26532 (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax +26533 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +26534 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +26535 89/<- %edx 0/r32/eax +26536 # if elemsize == 1 +26537 { +26538 81 7/subop/compare %ecx 1/imm32 +26539 75/jump-if-!= break/disp8 +26540 $translate-mu-length-stmt:size-1: +26541 (emit-save-size-to *(ebp+8) %ebx %edx) +26542 e9/jump $translate-mu-length-stmt:end/disp32 +26543 } +26544 # if elemsize is a power of 2 less than 256 +26545 { +26546 (power-of-2? %ecx *(ebp+0x10) *(ebp+0x14)) # => eax +26547 3d/compare-eax-and 0/imm32/false +26548 74/jump-if-= break/disp8 +26549 81 7/subop/compare %ecx 0xff/imm32 +26550 7f/jump-if-> break/disp8 +26551 $translate-mu-length-stmt:size-power-of-2: +26552 (emit-save-size-to *(ebp+8) %ebx %edx) +26553 (emit-divide-by-shift-right *(ebp+8) %edx %ecx) +26554 e9/jump $translate-mu-length-stmt:end/disp32 +26555 } +26556 # otherwise, the complex case +26557 # . emit register spills +26558 { +26559 $translate-mu-length-stmt:complex: +26560 (string-equal? %edx "eax") # => eax +26561 3d/compare-eax-and 0/imm32/false +26562 75/break-if-!= break/disp8 +26563 (emit-indent *(ebp+8) *Curr-block-depth) +26564 (write-buffered *(ebp+8) "50/push-eax\n") +26565 } +26566 { +26567 (string-equal? %edx "ecx") # => eax +26568 3d/compare-eax-and 0/imm32/false +26569 75/break-if-!= break/disp8 +26570 (emit-indent *(ebp+8) *Curr-block-depth) +26571 (write-buffered *(ebp+8) "51/push-ecx\n") +26572 } +26573 { +26574 (string-equal? %edx "edx") # => eax +26575 3d/compare-eax-and 0/imm32/false +26576 75/break-if-!= break/disp8 +26577 (emit-indent *(ebp+8) *Curr-block-depth) +26578 (write-buffered *(ebp+8) "52/push-edx\n") 26579 } -26580 $addr-handle-stream-payload-size:compute-size: -26581 # TODO: check t->is-atom? -26582 # return size(t->value) -26583 (size-of-type-id-as-array-element *(eax+4)) # Type-tree-value => eax -26584 $addr-handle-stream-payload-size:end: -26585 # . epilogue -26586 89/<- %esp 5/r32/ebp -26587 5d/pop-to-ebp -26588 c3/return -26589 -26590 power-of-2?: # n: int, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: boolean -26591 # precondition: n is positive -26592 # . prologue -26593 55/push-ebp -26594 89/<- %ebp 4/r32/esp -26595 # eax = n -26596 8b/-> *(ebp+8) 0/r32/eax -26597 # if (n < 0) abort -26598 3d/compare-eax-with 0/imm32 -26599 0f 8c/jump-if-< $power-of-2?:abort/disp32 -26600 # var tmp/eax: int = n-1 -26601 48/decrement-eax -26602 # var tmp2/eax: int = n & tmp -26603 23/and-> *(ebp+8) 0/r32/eax -26604 # return (tmp2 == 0) -26605 3d/compare-eax-and 0/imm32 -26606 0f 94/set-byte-if-= %al -26607 81 4/subop/and %eax 0xff/imm32 -26608 $power-of-2?:end: -26609 # . epilogue -26610 89/<- %esp 5/r32/ebp -26611 5d/pop-to-ebp -26612 c3/return -26613 -26614 $power-of-2?:abort: -26615 (write-buffered *(ebp+0xc) "power-of-2?: negative number\n") -26616 (flush *(ebp+0xc)) -26617 (stop *(ebp+0x10) 1) -26618 # never gets here -26619 -26620 num-shift-rights: # n: int -> result/eax: int -26621 # precondition: n is a positive power of 2 -26622 # . prologue -26623 55/push-ebp -26624 89/<- %ebp 4/r32/esp -26625 # . save registers -26626 51/push-ecx -26627 # var curr/ecx: int = n -26628 8b/-> *(ebp+8) 1/r32/ecx -26629 # result = 0 -26630 b8/copy-to-eax 0/imm32 -26631 { -26632 # if (curr <= 1) break -26633 81 7/subop/compare %ecx 1/imm32 -26634 7e/jump-if-<= break/disp8 -26635 40/increment-eax -26636 c1/shift 5/subop/arithmetic-right %ecx 1/imm8 -26637 eb/jump loop/disp8 -26638 } -26639 $num-shift-rights:end: -26640 # . restore registers -26641 59/pop-to-ecx -26642 # . epilogue -26643 89/<- %esp 5/r32/ebp -26644 5d/pop-to-ebp -26645 c3/return -26646 -26647 mu-get-offset: # stmt: (addr stmt) -> result/eax: int +26580 # . +26581 (emit-save-size-to *(ebp+8) %ebx "eax") +26582 (emit-indent *(ebp+8) *Curr-block-depth) +26583 (write-buffered *(ebp+8) "31/xor %edx 2/r32/edx\n") +26584 (emit-indent *(ebp+8) *Curr-block-depth) +26585 (write-buffered *(ebp+8) "b9/copy-to-ecx ") +26586 (write-int32-hex-buffered *(ebp+8) %ecx) +26587 (write-buffered *(ebp+8) "/imm32\n") +26588 (emit-indent *(ebp+8) *Curr-block-depth) +26589 (write-buffered *(ebp+8) "f7 7/subop/idiv-eax-edx-by %ecx\n") +26590 { +26591 (string-equal? %edx "eax") # => eax +26592 3d/compare-eax-and 0/imm32/false +26593 75/break-if-!= break/disp8 +26594 (emit-indent *(ebp+8) *Curr-block-depth) +26595 (write-buffered *(ebp+8) "89/<- %") +26596 (write-buffered *(ebp+8) %edx) +26597 (write-buffered *(ebp+8) " 0/r32/eax\n") +26598 } +26599 # . emit register restores +26600 { +26601 (string-equal? %edx "edx") # => eax +26602 3d/compare-eax-and 0/imm32/false +26603 75/break-if-!= break/disp8 +26604 (emit-indent *(ebp+8) *Curr-block-depth) +26605 (write-buffered *(ebp+8) "5a/pop-to-edx\n") +26606 } +26607 { +26608 (string-equal? %edx "ecx") # => eax +26609 3d/compare-eax-and 0/imm32/false +26610 75/break-if-!= break/disp8 +26611 (emit-indent *(ebp+8) *Curr-block-depth) +26612 (write-buffered *(ebp+8) "59/pop-to-ecx\n") +26613 } +26614 { +26615 (string-equal? %edx "eax") # => eax +26616 3d/compare-eax-and 0/imm32/false +26617 75/break-if-!= break/disp8 +26618 (emit-indent *(ebp+8) *Curr-block-depth) +26619 (write-buffered *(ebp+8) "58/pop-to-eax\n") +26620 } +26621 $translate-mu-length-stmt:end: +26622 # . restore registers +26623 5e/pop-to-esi +26624 5b/pop-to-ebx +26625 5a/pop-to-edx +26626 59/pop-to-ecx +26627 58/pop-to-eax +26628 # . epilogue +26629 89/<- %esp 5/r32/ebp +26630 5d/pop-to-ebp +26631 c3/return +26632 +26633 array-element-size: # arr: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +26634 # . prologue +26635 55/push-ebp +26636 89/<- %ebp 4/r32/esp +26637 # +26638 (array-element-type-id *(ebp+8) *(ebp+0xc) *(ebp+0x10)) # => eax +26639 (size-of-type-id-as-array-element %eax) # => eax +26640 $array-element-size:end: +26641 # . epilogue +26642 89/<- %esp 5/r32/ebp +26643 5d/pop-to-ebp +26644 c3/return +26645 +26646 array-element-type-id: # v: (addr var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: type-id +26647 # precondition: n is positive 26648 # . prologue 26649 55/push-ebp 26650 89/<- %ebp 4/r32/esp -26651 # var second-inout/eax: (addr stmt-var) = stmt->inouts->next +26651 # 26652 8b/-> *(ebp+8) 0/r32/eax -26653 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax -26654 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -26655 # var output-var/eax: (addr var) = second-inout->value -26656 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -26657 #? (write-buffered Stderr "mu-get-offset: ") -26658 #? (write-int32-hex-buffered Stderr %eax) -26659 #? (write-buffered Stderr " name: ") -26660 #? 50/push-eax -26661 #? (lookup *eax *(eax+4)) # Var-name -26662 #? (write-buffered Stderr %eax) -26663 #? 58/pop-to-eax -26664 #? (write-buffered Stderr Newline) -26665 #? (flush Stderr) -26666 # return output-var->stack-offset -26667 8b/-> *(eax+0x14) 0/r32/eax # Var-offset -26668 #? (write-buffered Stderr "=> ") -26669 #? (write-int32-hex-buffered Stderr %eax) -26670 #? (write-buffered Stderr Newline) -26671 #? (flush Stderr) -26672 $emit-get-offset:end: -26673 # . epilogue -26674 89/<- %esp 5/r32/ebp -26675 5d/pop-to-ebp -26676 c3/return -26677 -26678 emit-subx-block: # out: (addr buffered-file), block: (addr block), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) -26679 # . prologue -26680 55/push-ebp -26681 89/<- %ebp 4/r32/esp -26682 # . save registers -26683 50/push-eax -26684 51/push-ecx -26685 56/push-esi -26686 # esi = block -26687 8b/-> *(ebp+0xc) 6/r32/esi -26688 # block->var->block-depth = *Curr-block-depth -26689 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax -26690 8b/-> *Curr-block-depth 1/r32/ecx -26691 89/<- *(eax+0x10) 1/r32/ecx # Var-block-depth -26692 # var stmts/eax: (addr list stmt) = lookup(block->statements) -26693 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax -26694 # -26695 { -26696 $emit-subx-block:check-empty: -26697 3d/compare-eax-and 0/imm32 -26698 0f 84/jump-if-= break/disp32 -26699 (emit-indent *(ebp+8) *Curr-block-depth) -26700 (write-buffered *(ebp+8) "{\n") -26701 # var v/ecx: (addr var) = lookup(block->var) -26702 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax -26703 89/<- %ecx 0/r32/eax -26704 # -26705 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -26706 (write-buffered *(ebp+8) %eax) -26707 (write-buffered *(ebp+8) ":loop:\n") -26708 ff 0/subop/increment *Curr-block-depth -26709 (push *(ebp+0x10) *(esi+0xc)) # Block-var -26710 (push *(ebp+0x10) *(esi+0x10)) # Block-var -26711 (push *(ebp+0x10) 0) # false -26712 # emit block->statements -26713 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax -26714 (emit-subx-stmt-list *(ebp+8) %eax *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) -26715 (pop *(ebp+0x10)) # => eax -26716 (pop *(ebp+0x10)) # => eax -26717 (pop *(ebp+0x10)) # => eax -26718 ff 1/subop/decrement *Curr-block-depth -26719 (emit-indent *(ebp+8) *Curr-block-depth) -26720 (write-buffered *(ebp+8) "}\n") -26721 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax -26722 (write-buffered *(ebp+8) %eax) -26723 (write-buffered *(ebp+8) ":break:\n") -26724 } -26725 $emit-subx-block:end: -26726 # . restore registers -26727 5e/pop-to-esi -26728 59/pop-to-ecx -26729 58/pop-to-eax -26730 # . epilogue -26731 89/<- %esp 5/r32/ebp -26732 5d/pop-to-ebp -26733 c3/return -26734 -26735 # Primitives supported -26736 # See mu_instructions for a summary of this linked-list data structure. -26737 # -26738 # For each operation, put variants with hard-coded registers before flexible ones. -26739 # -26740 # Unfortunately, our restrictions on addresses require that various fields in -26741 # primitives be handles, which complicates these definitions. -26742 # - we need to insert dummy fields all over the place for fake alloc-ids -26743 # - we can't use our syntax sugar of quoted literals for string fields -26744 # -26745 # Fake alloc-ids are needed because our type definitions up top require -26746 # handles but it's clearer to statically allocate these long-lived objects. -26747 # Fake alloc-ids are perfectly safe, but they can't be reclaimed. -26748 # -26749 # Every 'object' below starts with a fake alloc-id. It may also contain other -26750 # fake alloc-ids for various handle fields. -26751 # -26752 # I think of objects starting with a fake alloc-id as having type 'payload'. -26753 # It's not really intended to be created dynamically; for that use `allocate` -26754 # as usual. -26755 # -26756 # Idea for a notation to simplify such definitions: -26757 # _Primitive-increment-eax: # (payload primitive) -26758 # 0x11/alloc-id:fake:payload -26759 # 0x11 @(0x11 "increment") # name -26760 # 0 0 # inouts -26761 # 0x11 @(0x11/payload -26762 # 0x11 @(0x11/payload # List-value -26763 # 0 0 # Var-name -26764 # 0x11 @(0x11 # Var-type -26765 # 1/is-atom -26766 # 1/value 0/unused # Type-tree-left -26767 # 0 0 # Type-tree-right -26768 # ) -26769 # 1 # block-depth -26770 # 0 # stack-offset -26771 # 0x11 @(0x11 "eax") # Var-register -26772 # ) -26773 # 0 0) # List-next -26774 # ... -26775 # _Primitive-increment-ecx/imm32/next -26776 # ... -26777 # Awfully complex and non-obvious. But also clearly signals there's something -26778 # to learn here, so may be worth trying. -26779 # -26780 # '@' is just an initial thought. Punctuation used so far in Mu: () * % # / " -26781 # -26782 # For now we'll continue to just use comments and manually ensure they stay up -26783 # to date. -26784 == data -26785 Primitives: # (addr primitive) -26786 # - increment/decrement -26787 _Primitive-increment-eax: # (addr primitive) -26788 # var/eax <- increment => 40/increment-eax -26789 0x11/imm32/alloc-id:fake -26790 _string-increment/imm32/name -26791 0/imm32/no-inouts -26792 0/imm32/no-inouts -26793 0x11/imm32/alloc-id:fake -26794 Single-int-var-in-eax/imm32/outputs -26795 0x11/imm32/alloc-id:fake -26796 _string_40_increment_eax/imm32/subx-name -26797 0/imm32/no-rm32 -26798 0/imm32/no-r32 -26799 0/imm32/no-imm32 -26800 0/imm32/no-imm8 -26801 0/imm32/no-disp32 -26802 0/imm32/no-xm32 -26803 0/imm32/no-x32 -26804 0x11/imm32/alloc-id:fake -26805 _Primitive-increment-ecx/imm32/next -26806 _Primitive-increment-ecx: # (payload primitive) -26807 0x11/imm32/alloc-id:fake:payload -26808 # var/ecx <- increment => 41/increment-ecx -26809 0x11/imm32/alloc-id:fake -26810 _string-increment/imm32/name -26811 0/imm32/no-inouts -26812 0/imm32/no-inouts -26813 0x11/imm32/alloc-id:fake -26814 Single-int-var-in-ecx/imm32/outputs -26815 0x11/imm32/alloc-id:fake -26816 _string_41_increment_ecx/imm32/subx-name -26817 0/imm32/no-rm32 -26818 0/imm32/no-r32 -26819 0/imm32/no-imm32 -26820 0/imm32/no-imm8 -26821 0/imm32/no-disp32 -26822 0/imm32/no-xm32 -26823 0/imm32/no-x32 -26824 0x11/imm32/alloc-id:fake -26825 _Primitive-increment-edx/imm32/next -26826 _Primitive-increment-edx: # (payload primitive) -26827 0x11/imm32/alloc-id:fake:payload -26828 # var/edx <- increment => 42/increment-edx -26829 0x11/imm32/alloc-id:fake -26830 _string-increment/imm32/name -26831 0/imm32/no-inouts -26832 0/imm32/no-inouts -26833 0x11/imm32/alloc-id:fake -26834 Single-int-var-in-edx/imm32/outputs -26835 0x11/imm32/alloc-id:fake -26836 _string_42_increment_edx/imm32/subx-name -26837 0/imm32/no-rm32 -26838 0/imm32/no-r32 -26839 0/imm32/no-imm32 -26840 0/imm32/no-imm8 -26841 0/imm32/no-disp32 -26842 0/imm32/no-xm32 -26843 0/imm32/no-x32 -26844 0x11/imm32/alloc-id:fake -26845 _Primitive-increment-ebx/imm32/next -26846 _Primitive-increment-ebx: # (payload primitive) -26847 0x11/imm32/alloc-id:fake:payload -26848 # var/ebx <- increment => 43/increment-ebx -26849 0x11/imm32/alloc-id:fake -26850 _string-increment/imm32/name -26851 0/imm32/no-inouts -26852 0/imm32/no-inouts -26853 0x11/imm32/alloc-id:fake -26854 Single-int-var-in-ebx/imm32/outputs -26855 0x11/imm32/alloc-id:fake -26856 _string_43_increment_ebx/imm32/subx-name -26857 0/imm32/no-rm32 -26858 0/imm32/no-r32 -26859 0/imm32/no-imm32 -26860 0/imm32/no-imm8 -26861 0/imm32/no-disp32 -26862 0/imm32/no-xm32 -26863 0/imm32/no-x32 -26864 0x11/imm32/alloc-id:fake -26865 _Primitive-increment-esi/imm32/next -26866 _Primitive-increment-esi: # (payload primitive) -26867 0x11/imm32/alloc-id:fake:payload -26868 # var/esi <- increment => 46/increment-esi -26869 0x11/imm32/alloc-id:fake -26870 _string-increment/imm32/name -26871 0/imm32/no-inouts -26872 0/imm32/no-inouts -26873 0x11/imm32/alloc-id:fake -26874 Single-int-var-in-esi/imm32/outputs -26875 0x11/imm32/alloc-id:fake -26876 _string_46_increment_esi/imm32/subx-name -26877 0/imm32/no-rm32 -26878 0/imm32/no-r32 -26879 0/imm32/no-imm32 -26880 0/imm32/no-imm8 -26881 0/imm32/no-disp32 -26882 0/imm32/no-xm32 -26883 0/imm32/no-x32 -26884 0x11/imm32/alloc-id:fake -26885 _Primitive-increment-edi/imm32/next -26886 _Primitive-increment-edi: # (payload primitive) -26887 0x11/imm32/alloc-id:fake:payload -26888 # var/edi <- increment => 47/increment-edi -26889 0x11/imm32/alloc-id:fake -26890 _string-increment/imm32/name -26891 0/imm32/no-inouts -26892 0/imm32/no-inouts -26893 0x11/imm32/alloc-id:fake -26894 Single-int-var-in-edi/imm32/outputs -26895 0x11/imm32/alloc-id:fake -26896 _string_47_increment_edi/imm32/subx-name -26897 0/imm32/no-rm32 -26898 0/imm32/no-r32 -26899 0/imm32/no-imm32 -26900 0/imm32/no-imm8 -26901 0/imm32/no-disp32 -26902 0/imm32/no-xm32 -26903 0/imm32/no-x32 -26904 0x11/imm32/alloc-id:fake -26905 _Primitive-decrement-eax/imm32/next -26906 _Primitive-decrement-eax: # (payload primitive) -26907 0x11/imm32/alloc-id:fake:payload -26908 # var/eax <- decrement => 48/decrement-eax -26909 0x11/imm32/alloc-id:fake -26910 _string-decrement/imm32/name -26911 0/imm32/no-inouts -26912 0/imm32/no-inouts -26913 0x11/imm32/alloc-id:fake -26914 Single-int-var-in-eax/imm32/outputs -26915 0x11/imm32/alloc-id:fake -26916 _string_48_decrement_eax/imm32/subx-name -26917 0/imm32/no-rm32 -26918 0/imm32/no-r32 -26919 0/imm32/no-imm32 -26920 0/imm32/no-imm8 -26921 0/imm32/no-disp32 -26922 0/imm32/no-xm32 -26923 0/imm32/no-x32 -26924 0x11/imm32/alloc-id:fake -26925 _Primitive-decrement-ecx/imm32/next -26926 _Primitive-decrement-ecx: # (payload primitive) -26927 0x11/imm32/alloc-id:fake:payload -26928 # var/ecx <- decrement => 49/decrement-ecx -26929 0x11/imm32/alloc-id:fake -26930 _string-decrement/imm32/name -26931 0/imm32/no-inouts -26932 0/imm32/no-inouts -26933 0x11/imm32/alloc-id:fake -26934 Single-int-var-in-ecx/imm32/outputs -26935 0x11/imm32/alloc-id:fake -26936 _string_49_decrement_ecx/imm32/subx-name -26937 0/imm32/no-rm32 -26938 0/imm32/no-r32 -26939 0/imm32/no-imm32 -26940 0/imm32/no-imm8 -26941 0/imm32/no-disp32 -26942 0/imm32/no-xm32 -26943 0/imm32/no-x32 -26944 0x11/imm32/alloc-id:fake -26945 _Primitive-decrement-edx/imm32/next -26946 _Primitive-decrement-edx: # (payload primitive) -26947 0x11/imm32/alloc-id:fake:payload -26948 # var/edx <- decrement => 4a/decrement-edx -26949 0x11/imm32/alloc-id:fake -26950 _string-decrement/imm32/name -26951 0/imm32/no-inouts -26952 0/imm32/no-inouts -26953 0x11/imm32/alloc-id:fake -26954 Single-int-var-in-edx/imm32/outputs -26955 0x11/imm32/alloc-id:fake -26956 _string_4a_decrement_edx/imm32/subx-name -26957 0/imm32/no-rm32 -26958 0/imm32/no-r32 -26959 0/imm32/no-imm32 -26960 0/imm32/no-imm8 -26961 0/imm32/no-disp32 -26962 0/imm32/no-xm32 -26963 0/imm32/no-x32 -26964 0x11/imm32/alloc-id:fake -26965 _Primitive-decrement-ebx/imm32/next -26966 _Primitive-decrement-ebx: # (payload primitive) -26967 0x11/imm32/alloc-id:fake:payload -26968 # var/ebx <- decrement => 4b/decrement-ebx -26969 0x11/imm32/alloc-id:fake -26970 _string-decrement/imm32/name -26971 0/imm32/no-inouts -26972 0/imm32/no-inouts -26973 0x11/imm32/alloc-id:fake -26974 Single-int-var-in-ebx/imm32/outputs -26975 0x11/imm32/alloc-id:fake -26976 _string_4b_decrement_ebx/imm32/subx-name -26977 0/imm32/no-rm32 -26978 0/imm32/no-r32 -26979 0/imm32/no-imm32 -26980 0/imm32/no-imm8 -26981 0/imm32/no-disp32 -26982 0/imm32/no-xm32 -26983 0/imm32/no-x32 -26984 0x11/imm32/alloc-id:fake -26985 _Primitive-decrement-esi/imm32/next -26986 _Primitive-decrement-esi: # (payload primitive) -26987 0x11/imm32/alloc-id:fake:payload -26988 # var/esi <- decrement => 4e/decrement-esi -26989 0x11/imm32/alloc-id:fake -26990 _string-decrement/imm32/name -26991 0/imm32/no-inouts -26992 0/imm32/no-inouts -26993 0x11/imm32/alloc-id:fake -26994 Single-int-var-in-esi/imm32/outputs -26995 0x11/imm32/alloc-id:fake -26996 _string_4e_decrement_esi/imm32/subx-name -26997 0/imm32/no-rm32 -26998 0/imm32/no-r32 -26999 0/imm32/no-imm32 -27000 0/imm32/no-imm8 -27001 0/imm32/no-disp32 -27002 0/imm32/no-xm32 -27003 0/imm32/no-x32 -27004 0x11/imm32/alloc-id:fake -27005 _Primitive-decrement-edi/imm32/next -27006 _Primitive-decrement-edi: # (payload primitive) -27007 0x11/imm32/alloc-id:fake:payload -27008 # var/edi <- decrement => 4f/decrement-edi -27009 0x11/imm32/alloc-id:fake -27010 _string-decrement/imm32/name -27011 0/imm32/no-inouts -27012 0/imm32/no-inouts -27013 0x11/imm32/alloc-id:fake -27014 Single-int-var-in-edi/imm32/outputs -27015 0x11/imm32/alloc-id:fake -27016 _string_4f_decrement_edi/imm32/subx-name -27017 0/imm32/no-rm32 -27018 0/imm32/no-r32 -27019 0/imm32/no-imm32 -27020 0/imm32/no-imm8 -27021 0/imm32/no-disp32 -27022 0/imm32/no-xm32 -27023 0/imm32/no-x32 -27024 0x11/imm32/alloc-id:fake -27025 _Primitive-increment-mem/imm32/next -27026 _Primitive-increment-mem: # (payload primitive) -27027 0x11/imm32/alloc-id:fake:payload -27028 # increment var => ff 0/subop/increment *(ebp+__) -27029 0x11/imm32/alloc-id:fake -27030 _string-increment/imm32/name -27031 0x11/imm32/alloc-id:fake -27032 Single-int-var-in-mem/imm32/inouts -27033 0/imm32/no-outputs -27034 0/imm32/no-outputs -27035 0x11/imm32/alloc-id:fake -27036 _string_ff_subop_increment/imm32/subx-name -27037 1/imm32/rm32-is-first-inout -27038 0/imm32/no-r32 -27039 0/imm32/no-imm32 -27040 0/imm32/no-imm8 -27041 0/imm32/no-disp32 -27042 0/imm32/no-xm32 -27043 0/imm32/no-x32 -27044 0x11/imm32/alloc-id:fake -27045 _Primitive-increment-reg/imm32/next -27046 _Primitive-increment-reg: # (payload primitive) -27047 0x11/imm32/alloc-id:fake:payload -27048 # var/reg <- increment => ff 0/subop/increment %__ -27049 0x11/imm32/alloc-id:fake -27050 _string-increment/imm32/name -27051 0/imm32/no-inouts -27052 0/imm32/no-inouts -27053 0x11/imm32/alloc-id:fake -27054 Single-int-var-in-some-register/imm32/outputs -27055 0x11/imm32/alloc-id:fake -27056 _string_ff_subop_increment/imm32/subx-name -27057 3/imm32/rm32-is-first-output -27058 0/imm32/no-r32 -27059 0/imm32/no-imm32 -27060 0/imm32/no-imm8 -27061 0/imm32/no-disp32 -27062 0/imm32/no-xm32 -27063 0/imm32/no-x32 -27064 0x11/imm32/alloc-id:fake -27065 _Primitive-decrement-mem/imm32/next -27066 _Primitive-decrement-mem: # (payload primitive) -27067 0x11/imm32/alloc-id:fake:payload -27068 # decrement var => ff 1/subop/decrement *(ebp+__) -27069 0x11/imm32/alloc-id:fake -27070 _string-decrement/imm32/name -27071 0x11/imm32/alloc-id:fake -27072 Single-int-var-in-mem/imm32/inouts -27073 0/imm32/no-outputs -27074 0/imm32/no-outputs -27075 0x11/imm32/alloc-id:fake -27076 _string_ff_subop_decrement/imm32/subx-name -27077 1/imm32/rm32-is-first-inout -27078 0/imm32/no-r32 -27079 0/imm32/no-imm32 -27080 0/imm32/no-imm8 -27081 0/imm32/no-disp32 -27082 0/imm32/no-xm32 -27083 0/imm32/no-x32 -27084 0x11/imm32/alloc-id:fake -27085 _Primitive-decrement-reg/imm32/next -27086 _Primitive-decrement-reg: # (payload primitive) -27087 0x11/imm32/alloc-id:fake:payload -27088 # var/reg <- decrement => ff 1/subop/decrement %__ -27089 0x11/imm32/alloc-id:fake -27090 _string-decrement/imm32/name -27091 0/imm32/no-inouts -27092 0/imm32/no-inouts -27093 0x11/imm32/alloc-id:fake -27094 Single-int-var-in-some-register/imm32/outputs -27095 0x11/imm32/alloc-id:fake -27096 _string_ff_subop_decrement/imm32/subx-name -27097 3/imm32/rm32-is-first-output -27098 0/imm32/no-r32 -27099 0/imm32/no-imm32 -27100 0/imm32/no-imm8 -27101 0/imm32/no-disp32 -27102 0/imm32/no-xm32 -27103 0/imm32/no-x32 -27104 0x11/imm32/alloc-id:fake -27105 _Primitive-add-to-eax/imm32/next -27106 # - add -27107 _Primitive-add-to-eax: # (payload primitive) -27108 0x11/imm32/alloc-id:fake:payload -27109 # var/eax <- add lit => 05/add-to-eax lit/imm32 -27110 0x11/imm32/alloc-id:fake -27111 _string-add/imm32/name -27112 0x11/imm32/alloc-id:fake -27113 Single-lit-var/imm32/inouts -27114 0x11/imm32/alloc-id:fake -27115 Single-int-var-in-eax/imm32/outputs -27116 0x11/imm32/alloc-id:fake -27117 _string_05_add_to_eax/imm32/subx-name -27118 0/imm32/no-rm32 -27119 0/imm32/no-r32 -27120 1/imm32/imm32-is-first-inout -27121 0/imm32/no-imm8 -27122 0/imm32/no-disp32 -27123 0/imm32/no-xm32 -27124 0/imm32/no-x32 -27125 0x11/imm32/alloc-id:fake -27126 _Primitive-add-reg-to-reg/imm32/next -27127 _Primitive-add-reg-to-reg: # (payload primitive) -27128 0x11/imm32/alloc-id:fake:payload -27129 # var1/reg <- add var2/reg => 01/add-to var1/rm32 var2/r32 -27130 0x11/imm32/alloc-id:fake -27131 _string-add/imm32/name -27132 0x11/imm32/alloc-id:fake -27133 Single-int-var-in-some-register/imm32/inouts -27134 0x11/imm32/alloc-id:fake -27135 Single-int-var-in-some-register/imm32/outputs -27136 0x11/imm32/alloc-id:fake -27137 _string_01_add_to/imm32/subx-name -27138 3/imm32/rm32-is-first-output -27139 1/imm32/r32-is-first-inout -27140 0/imm32/no-imm32 -27141 0/imm32/no-imm8 -27142 0/imm32/no-disp32 -27143 0/imm32/no-xm32 -27144 0/imm32/no-x32 -27145 0x11/imm32/alloc-id:fake -27146 _Primitive-add-reg-to-mem/imm32/next -27147 _Primitive-add-reg-to-mem: # (payload primitive) -27148 0x11/imm32/alloc-id:fake:payload -27149 # add-to var1 var2/reg => 01/add-to var1 var2/r32 -27150 0x11/imm32/alloc-id:fake -27151 _string-add-to/imm32/name -27152 0x11/imm32/alloc-id:fake -27153 Two-args-int-stack-int-reg/imm32/inouts -27154 0/imm32/no-outputs -27155 0/imm32/no-outputs -27156 0x11/imm32/alloc-id:fake -27157 _string_01_add_to/imm32/subx-name -27158 1/imm32/rm32-is-first-inout -27159 2/imm32/r32-is-second-inout -27160 0/imm32/no-imm32 -27161 0/imm32/no-imm8 -27162 0/imm32/no-disp32 -27163 0/imm32/no-xm32 -27164 0/imm32/no-x32 -27165 0x11/imm32/alloc-id:fake -27166 _Primitive-add-mem-to-reg/imm32/next -27167 _Primitive-add-mem-to-reg: # (payload primitive) -27168 0x11/imm32/alloc-id:fake:payload -27169 # var1/reg <- add var2 => 03/add var2/rm32 var1/r32 -27170 0x11/imm32/alloc-id:fake -27171 _string-add/imm32/name -27172 0x11/imm32/alloc-id:fake -27173 Single-int-var-in-mem/imm32/inouts -27174 0x11/imm32/alloc-id:fake -27175 Single-int-var-in-some-register/imm32/outputs -27176 0x11/imm32/alloc-id:fake -27177 _string_03_add/imm32/subx-name -27178 1/imm32/rm32-is-first-inout -27179 3/imm32/r32-is-first-output -27180 0/imm32/no-imm32 -27181 0/imm32/no-imm8 -27182 0/imm32/no-disp32 -27183 0/imm32/no-xm32 -27184 0/imm32/no-x32 -27185 0x11/imm32/alloc-id:fake -27186 _Primitive-add-lit-to-reg/imm32/next -27187 _Primitive-add-lit-to-reg: # (payload primitive) -27188 0x11/imm32/alloc-id:fake:payload -27189 # var1/reg <- add lit => 81 0/subop/add var1/rm32 lit/imm32 -27190 0x11/imm32/alloc-id:fake -27191 _string-add/imm32/name -27192 0x11/imm32/alloc-id:fake -27193 Single-lit-var/imm32/inouts -27194 0x11/imm32/alloc-id:fake -27195 Single-int-var-in-some-register/imm32/outputs -27196 0x11/imm32/alloc-id:fake -27197 _string_81_subop_add/imm32/subx-name -27198 3/imm32/rm32-is-first-output -27199 0/imm32/no-r32 -27200 1/imm32/imm32-is-first-inout -27201 0/imm32/no-imm8 -27202 0/imm32/no-disp32 -27203 0/imm32/no-xm32 -27204 0/imm32/no-x32 -27205 0x11/imm32/alloc-id:fake -27206 _Primitive-add-lit-to-mem/imm32/next -27207 _Primitive-add-lit-to-mem: # (payload primitive) -27208 0x11/imm32/alloc-id:fake:payload -27209 # add-to var1, lit => 81 0/subop/add var1/rm32 lit/imm32 -27210 0x11/imm32/alloc-id:fake -27211 _string-add-to/imm32/name -27212 0x11/imm32/alloc-id:fake -27213 Int-var-and-literal/imm32/inouts -27214 0/imm32/no-outputs -27215 0/imm32/no-outputs -27216 0x11/imm32/alloc-id:fake -27217 _string_81_subop_add/imm32/subx-name -27218 1/imm32/rm32-is-first-inout -27219 0/imm32/no-r32 -27220 2/imm32/imm32-is-second-inout -27221 0/imm32/no-imm8 -27222 0/imm32/no-disp32 -27223 0/imm32/no-xm32 -27224 0/imm32/no-x32 -27225 0x11/imm32/alloc-id:fake -27226 _Primitive-subtract-from-eax/imm32/next -27227 # - subtract -27228 _Primitive-subtract-from-eax: # (payload primitive) -27229 0x11/imm32/alloc-id:fake:payload -27230 # var/eax <- subtract lit => 2d/subtract-from-eax lit/imm32 -27231 0x11/imm32/alloc-id:fake -27232 _string-subtract/imm32/name -27233 0x11/imm32/alloc-id:fake -27234 Single-lit-var/imm32/inouts -27235 0x11/imm32/alloc-id:fake -27236 Single-int-var-in-eax/imm32/outputs -27237 0x11/imm32/alloc-id:fake -27238 _string_2d_subtract_from_eax/imm32/subx-name -27239 0/imm32/no-rm32 -27240 0/imm32/no-r32 -27241 1/imm32/imm32-is-first-inout -27242 0/imm32/no-imm8 -27243 0/imm32/no-disp32 -27244 0/imm32/no-xm32 -27245 0/imm32/no-x32 -27246 0x11/imm32/alloc-id:fake -27247 _Primitive-subtract-reg-from-reg/imm32/next -27248 _Primitive-subtract-reg-from-reg: # (payload primitive) -27249 0x11/imm32/alloc-id:fake:payload -27250 # var1/reg <- subtract var2/reg => 29/subtract-from var1/rm32 var2/r32 -27251 0x11/imm32/alloc-id:fake -27252 _string-subtract/imm32/name -27253 0x11/imm32/alloc-id:fake -27254 Single-int-var-in-some-register/imm32/inouts -27255 0x11/imm32/alloc-id:fake -27256 Single-int-var-in-some-register/imm32/outputs -27257 0x11/imm32/alloc-id:fake -27258 _string_29_subtract_from/imm32/subx-name -27259 3/imm32/rm32-is-first-output -27260 1/imm32/r32-is-first-inout -27261 0/imm32/no-imm32 -27262 0/imm32/no-imm8 -27263 0/imm32/no-disp32 -27264 0/imm32/no-xm32 -27265 0/imm32/no-x32 -27266 0x11/imm32/alloc-id:fake -27267 _Primitive-subtract-reg-from-mem/imm32/next -27268 _Primitive-subtract-reg-from-mem: # (payload primitive) -27269 0x11/imm32/alloc-id:fake:payload -27270 # subtract-from var1 var2/reg => 29/subtract-from var1 var2/r32 -27271 0x11/imm32/alloc-id:fake -27272 _string-subtract-from/imm32/name -27273 0x11/imm32/alloc-id:fake -27274 Two-args-int-stack-int-reg/imm32/inouts -27275 0/imm32/no-outputs -27276 0/imm32/no-outputs -27277 0x11/imm32/alloc-id:fake -27278 _string_29_subtract_from/imm32/subx-name -27279 1/imm32/rm32-is-first-inout -27280 2/imm32/r32-is-second-inout -27281 0/imm32/no-imm32 -27282 0/imm32/no-imm8 -27283 0/imm32/no-disp32 -27284 0/imm32/no-xm32 -27285 0/imm32/no-x32 -27286 0x11/imm32/alloc-id:fake -27287 _Primitive-subtract-mem-from-reg/imm32/next -27288 _Primitive-subtract-mem-from-reg: # (payload primitive) -27289 0x11/imm32/alloc-id:fake:payload -27290 # var1/reg <- subtract var2 => 2b/subtract var2/rm32 var1/r32 -27291 0x11/imm32/alloc-id:fake -27292 _string-subtract/imm32/name -27293 0x11/imm32/alloc-id:fake -27294 Single-int-var-in-mem/imm32/inouts -27295 0x11/imm32/alloc-id:fake -27296 Single-int-var-in-some-register/imm32/outputs -27297 0x11/imm32/alloc-id:fake -27298 _string_2b_subtract/imm32/subx-name -27299 1/imm32/rm32-is-first-inout -27300 3/imm32/r32-is-first-output -27301 0/imm32/no-imm32 -27302 0/imm32/no-imm8 -27303 0/imm32/no-disp32 -27304 0/imm32/no-xm32 -27305 0/imm32/no-x32 -27306 0x11/imm32/alloc-id:fake -27307 _Primitive-subtract-lit-from-reg/imm32/next -27308 _Primitive-subtract-lit-from-reg: # (payload primitive) -27309 0x11/imm32/alloc-id:fake:payload -27310 # var1/reg <- subtract lit => 81 5/subop/subtract var1/rm32 lit/imm32 -27311 0x11/imm32/alloc-id:fake -27312 _string-subtract/imm32/name -27313 0x11/imm32/alloc-id:fake -27314 Single-lit-var/imm32/inouts -27315 0x11/imm32/alloc-id:fake -27316 Single-int-var-in-some-register/imm32/outputs -27317 0x11/imm32/alloc-id:fake -27318 _string_81_subop_subtract/imm32/subx-name -27319 3/imm32/rm32-is-first-output -27320 0/imm32/no-r32 -27321 1/imm32/imm32-is-first-inout -27322 0/imm32/no-imm8 -27323 0/imm32/no-disp32 -27324 0/imm32/no-xm32 -27325 0/imm32/no-x32 -27326 0x11/imm32/alloc-id:fake -27327 _Primitive-subtract-lit-from-mem/imm32/next -27328 _Primitive-subtract-lit-from-mem: # (payload primitive) -27329 0x11/imm32/alloc-id:fake:payload -27330 # subtract-from var1, lit => 81 5/subop/subtract var1/rm32 lit/imm32 -27331 0x11/imm32/alloc-id:fake -27332 _string-subtract-from/imm32/name -27333 0x11/imm32/alloc-id:fake -27334 Int-var-and-literal/imm32/inouts -27335 0/imm32/no-outputs -27336 0/imm32/no-outputs -27337 0x11/imm32/alloc-id:fake -27338 _string_81_subop_subtract/imm32/subx-name -27339 1/imm32/rm32-is-first-inout -27340 0/imm32/no-r32 -27341 2/imm32/imm32-is-second-inout -27342 0/imm32/no-imm8 -27343 0/imm32/no-disp32 -27344 0/imm32/no-xm32 -27345 0/imm32/no-x32 -27346 0x11/imm32/alloc-id:fake -27347 _Primitive-and-with-eax/imm32/next -27348 # - and -27349 _Primitive-and-with-eax: # (payload primitive) -27350 0x11/imm32/alloc-id:fake:payload -27351 # var/eax <- and lit => 25/and-with-eax lit/imm32 -27352 0x11/imm32/alloc-id:fake -27353 _string-and/imm32/name -27354 0x11/imm32/alloc-id:fake -27355 Single-lit-var/imm32/inouts -27356 0x11/imm32/alloc-id:fake -27357 Single-int-var-in-eax/imm32/outputs -27358 0x11/imm32/alloc-id:fake -27359 _string_25_and_with_eax/imm32/subx-name -27360 0/imm32/no-rm32 -27361 0/imm32/no-r32 -27362 1/imm32/imm32-is-first-inout -27363 0/imm32/no-imm8 -27364 0/imm32/no-disp32 -27365 0/imm32/no-xm32 -27366 0/imm32/no-x32 -27367 0x11/imm32/alloc-id:fake -27368 _Primitive-and-reg-with-reg/imm32/next -27369 _Primitive-and-reg-with-reg: # (payload primitive) -27370 0x11/imm32/alloc-id:fake:payload -27371 # var1/reg <- and var2/reg => 21/and-with var1/rm32 var2/r32 -27372 0x11/imm32/alloc-id:fake -27373 _string-and/imm32/name -27374 0x11/imm32/alloc-id:fake -27375 Single-int-var-in-some-register/imm32/inouts -27376 0x11/imm32/alloc-id:fake -27377 Single-int-var-in-some-register/imm32/outputs -27378 0x11/imm32/alloc-id:fake -27379 _string_21_and_with/imm32/subx-name -27380 3/imm32/rm32-is-first-output -27381 1/imm32/r32-is-first-inout -27382 0/imm32/no-imm32 -27383 0/imm32/no-imm8 -27384 0/imm32/no-disp32 -27385 0/imm32/no-xm32 -27386 0/imm32/no-x32 -27387 0x11/imm32/alloc-id:fake -27388 _Primitive-and-reg-with-mem/imm32/next -27389 _Primitive-and-reg-with-mem: # (payload primitive) -27390 0x11/imm32/alloc-id:fake:payload -27391 # and-with var1 var2/reg => 21/and-with var1 var2/r32 -27392 0x11/imm32/alloc-id:fake -27393 _string-and-with/imm32/name -27394 0x11/imm32/alloc-id:fake -27395 Two-args-int-stack-int-reg/imm32/inouts -27396 0/imm32/no-outputs -27397 0/imm32/no-outputs -27398 0x11/imm32/alloc-id:fake -27399 _string_21_and_with/imm32/subx-name -27400 1/imm32/rm32-is-first-inout -27401 2/imm32/r32-is-second-inout -27402 0/imm32/no-imm32 -27403 0/imm32/no-imm8 -27404 0/imm32/no-disp32 -27405 0/imm32/no-xm32 -27406 0/imm32/no-x32 -27407 0x11/imm32/alloc-id:fake -27408 _Primitive-and-mem-with-reg/imm32/next -27409 _Primitive-and-mem-with-reg: # (payload primitive) -27410 0x11/imm32/alloc-id:fake:payload -27411 # var1/reg <- and var2 => 23/and var2/rm32 var1/r32 -27412 0x11/imm32/alloc-id:fake -27413 _string-and/imm32/name -27414 0x11/imm32/alloc-id:fake -27415 Single-int-var-in-mem/imm32/inouts -27416 0x11/imm32/alloc-id:fake -27417 Single-int-var-in-some-register/imm32/outputs -27418 0x11/imm32/alloc-id:fake -27419 _string_23_and/imm32/subx-name -27420 1/imm32/rm32-is-first-inout -27421 3/imm32/r32-is-first-output -27422 0/imm32/no-imm32 -27423 0/imm32/no-imm8 -27424 0/imm32/no-disp32 -27425 0/imm32/no-xm32 -27426 0/imm32/no-x32 -27427 0x11/imm32/alloc-id:fake -27428 _Primitive-and-lit-with-reg/imm32/next -27429 _Primitive-and-lit-with-reg: # (payload primitive) -27430 0x11/imm32/alloc-id:fake:payload -27431 # var1/reg <- and lit => 81 4/subop/and var1/rm32 lit/imm32 -27432 0x11/imm32/alloc-id:fake -27433 _string-and/imm32/name -27434 0x11/imm32/alloc-id:fake -27435 Single-lit-var/imm32/inouts -27436 0x11/imm32/alloc-id:fake -27437 Single-int-var-in-some-register/imm32/outputs -27438 0x11/imm32/alloc-id:fake -27439 _string_81_subop_and/imm32/subx-name -27440 3/imm32/rm32-is-first-output -27441 0/imm32/no-r32 -27442 1/imm32/imm32-is-first-inout -27443 0/imm32/no-imm8 -27444 0/imm32/no-disp32 -27445 0/imm32/no-xm32 -27446 0/imm32/no-x32 -27447 0x11/imm32/alloc-id:fake -27448 _Primitive-and-lit-with-mem/imm32/next -27449 _Primitive-and-lit-with-mem: # (payload primitive) -27450 0x11/imm32/alloc-id:fake:payload -27451 # and-with var1, lit => 81 4/subop/and var1/rm32 lit/imm32 -27452 0x11/imm32/alloc-id:fake -27453 _string-and-with/imm32/name -27454 0x11/imm32/alloc-id:fake -27455 Int-var-and-literal/imm32/inouts -27456 0/imm32/no-outputs -27457 0/imm32/no-outputs -27458 0x11/imm32/alloc-id:fake -27459 _string_81_subop_and/imm32/subx-name -27460 1/imm32/rm32-is-first-inout -27461 0/imm32/no-r32 -27462 2/imm32/imm32-is-second-inout -27463 0/imm32/no-imm8 -27464 0/imm32/no-disp32 -27465 0/imm32/no-xm32 -27466 0/imm32/no-x32 -27467 0x11/imm32/alloc-id:fake -27468 _Primitive-or-with-eax/imm32/next -27469 # - or -27470 _Primitive-or-with-eax: # (payload primitive) -27471 0x11/imm32/alloc-id:fake:payload -27472 # var/eax <- or lit => 0d/or-with-eax lit/imm32 -27473 0x11/imm32/alloc-id:fake -27474 _string-or/imm32/name -27475 0x11/imm32/alloc-id:fake -27476 Single-lit-var/imm32/inouts -27477 0x11/imm32/alloc-id:fake -27478 Single-int-var-in-eax/imm32/outputs -27479 0x11/imm32/alloc-id:fake -27480 _string_0d_or_with_eax/imm32/subx-name -27481 0/imm32/no-rm32 -27482 0/imm32/no-r32 -27483 1/imm32/imm32-is-first-inout -27484 0/imm32/no-imm8 -27485 0/imm32/no-disp32 -27486 0/imm32/no-xm32 -27487 0/imm32/no-x32 -27488 0x11/imm32/alloc-id:fake -27489 _Primitive-or-reg-with-reg/imm32/next -27490 _Primitive-or-reg-with-reg: # (payload primitive) -27491 0x11/imm32/alloc-id:fake:payload -27492 # var1/reg <- or var2/reg => 09/or-with var1/rm32 var2/r32 -27493 0x11/imm32/alloc-id:fake -27494 _string-or/imm32/name -27495 0x11/imm32/alloc-id:fake -27496 Single-int-var-in-some-register/imm32/inouts -27497 0x11/imm32/alloc-id:fake -27498 Single-int-var-in-some-register/imm32/outputs -27499 0x11/imm32/alloc-id:fake -27500 _string_09_or_with/imm32/subx-name -27501 3/imm32/rm32-is-first-output -27502 1/imm32/r32-is-first-inout -27503 0/imm32/no-imm32 -27504 0/imm32/no-imm8 -27505 0/imm32/no-disp32 -27506 0/imm32/no-xm32 -27507 0/imm32/no-x32 -27508 0x11/imm32/alloc-id:fake -27509 _Primitive-or-reg-with-mem/imm32/next -27510 _Primitive-or-reg-with-mem: # (payload primitive) -27511 0x11/imm32/alloc-id:fake:payload -27512 # or-with var1 var2/reg => 09/or-with var1 var2/r32 -27513 0x11/imm32/alloc-id:fake -27514 _string-or-with/imm32/name -27515 0x11/imm32/alloc-id:fake -27516 Two-args-int-stack-int-reg/imm32/inouts -27517 0/imm32/no-outputs -27518 0/imm32/no-outputs -27519 0x11/imm32/alloc-id:fake -27520 _string_09_or_with/imm32/subx-name -27521 1/imm32/rm32-is-first-inout -27522 2/imm32/r32-is-second-inout -27523 0/imm32/no-imm32 -27524 0/imm32/no-imm8 -27525 0/imm32/no-disp32 -27526 0/imm32/no-xm32 -27527 0/imm32/no-x32 -27528 0x11/imm32/alloc-id:fake -27529 _Primitive-or-mem-with-reg/imm32/next -27530 _Primitive-or-mem-with-reg: # (payload primitive) -27531 0x11/imm32/alloc-id:fake:payload -27532 # var1/reg <- or var2 => 0b/or var2/rm32 var1/r32 -27533 0x11/imm32/alloc-id:fake -27534 _string-or/imm32/name -27535 0x11/imm32/alloc-id:fake -27536 Single-int-var-in-mem/imm32/inouts -27537 0x11/imm32/alloc-id:fake -27538 Single-int-var-in-some-register/imm32/outputs -27539 0x11/imm32/alloc-id:fake -27540 _string_0b_or/imm32/subx-name -27541 1/imm32/rm32-is-first-inout -27542 3/imm32/r32-is-first-output -27543 0/imm32/no-imm32 -27544 0/imm32/no-imm8 -27545 0/imm32/no-disp32 -27546 0/imm32/no-xm32 -27547 0/imm32/no-x32 -27548 0x11/imm32/alloc-id:fake -27549 _Primitive-or-lit-with-reg/imm32/next -27550 _Primitive-or-lit-with-reg: # (payload primitive) -27551 0x11/imm32/alloc-id:fake:payload -27552 # var1/reg <- or lit => 81 1/subop/or var1/rm32 lit/imm32 -27553 0x11/imm32/alloc-id:fake -27554 _string-or/imm32/name -27555 0x11/imm32/alloc-id:fake -27556 Single-lit-var/imm32/inouts -27557 0x11/imm32/alloc-id:fake -27558 Single-int-var-in-some-register/imm32/outputs -27559 0x11/imm32/alloc-id:fake -27560 _string_81_subop_or/imm32/subx-name -27561 3/imm32/rm32-is-first-output -27562 0/imm32/no-r32 -27563 1/imm32/imm32-is-first-inout -27564 0/imm32/no-imm8 -27565 0/imm32/no-disp32 -27566 0/imm32/no-xm32 -27567 0/imm32/no-x32 -27568 0x11/imm32/alloc-id:fake -27569 _Primitive-or-lit-with-mem/imm32/next -27570 _Primitive-or-lit-with-mem: # (payload primitive) -27571 0x11/imm32/alloc-id:fake:payload -27572 # or-with var1, lit => 81 1/subop/or var1/rm32 lit/imm32 -27573 0x11/imm32/alloc-id:fake -27574 _string-or-with/imm32/name -27575 0x11/imm32/alloc-id:fake -27576 Int-var-and-literal/imm32/inouts -27577 0/imm32/no-outputs -27578 0/imm32/no-outputs -27579 0x11/imm32/alloc-id:fake -27580 _string_81_subop_or/imm32/subx-name -27581 1/imm32/rm32-is-first-inout -27582 0/imm32/no-r32 -27583 2/imm32/imm32-is-second-inout -27584 0/imm32/no-imm8 -27585 0/imm32/no-disp32 -27586 0/imm32/no-xm32 -27587 0/imm32/no-x32 -27588 0x11/imm32/alloc-id:fake -27589 _Primitive-xor-with-eax/imm32/next -27590 # - xor -27591 _Primitive-xor-with-eax: # (payload primitive) -27592 0x11/imm32/alloc-id:fake:payload -27593 # var/eax <- xor lit => 35/xor-with-eax lit/imm32 -27594 0x11/imm32/alloc-id:fake -27595 _string-xor/imm32/name -27596 0x11/imm32/alloc-id:fake -27597 Single-lit-var/imm32/inouts -27598 0x11/imm32/alloc-id:fake -27599 Single-int-var-in-eax/imm32/outputs -27600 0x11/imm32/alloc-id:fake -27601 _string_35_xor_with_eax/imm32/subx-name -27602 0/imm32/no-rm32 -27603 0/imm32/no-r32 -27604 1/imm32/imm32-is-first-inout -27605 0/imm32/no-imm8 -27606 0/imm32/no-disp32 -27607 0/imm32/no-xm32 -27608 0/imm32/no-x32 -27609 0x11/imm32/alloc-id:fake -27610 _Primitive-xor-reg-with-reg/imm32/next -27611 _Primitive-xor-reg-with-reg: # (payload primitive) -27612 0x11/imm32/alloc-id:fake:payload -27613 # var1/reg <- xor var2/reg => 31/xor-with var1/rm32 var2/r32 -27614 0x11/imm32/alloc-id:fake -27615 _string-xor/imm32/name -27616 0x11/imm32/alloc-id:fake -27617 Single-int-var-in-some-register/imm32/inouts -27618 0x11/imm32/alloc-id:fake -27619 Single-int-var-in-some-register/imm32/outputs -27620 0x11/imm32/alloc-id:fake -27621 _string_31_xor_with/imm32/subx-name -27622 3/imm32/rm32-is-first-output -27623 1/imm32/r32-is-first-inout -27624 0/imm32/no-imm32 -27625 0/imm32/no-imm8 -27626 0/imm32/no-disp32 -27627 0/imm32/no-xm32 -27628 0/imm32/no-x32 -27629 0x11/imm32/alloc-id:fake -27630 _Primitive-xor-reg-with-mem/imm32/next -27631 _Primitive-xor-reg-with-mem: # (payload primitive) -27632 0x11/imm32/alloc-id:fake:payload -27633 # xor-with var1 var2/reg => 31/xor-with var1 var2/r32 -27634 0x11/imm32/alloc-id:fake -27635 _string-xor-with/imm32/name -27636 0x11/imm32/alloc-id:fake -27637 Two-args-int-stack-int-reg/imm32/inouts -27638 0/imm32/no-outputs -27639 0/imm32/no-outputs -27640 0x11/imm32/alloc-id:fake -27641 _string_31_xor_with/imm32/subx-name -27642 1/imm32/rm32-is-first-inout -27643 2/imm32/r32-is-second-inout -27644 0/imm32/no-imm32 -27645 0/imm32/no-imm8 -27646 0/imm32/no-disp32 -27647 0/imm32/no-xm32 -27648 0/imm32/no-x32 -27649 0x11/imm32/alloc-id:fake -27650 _Primitive-xor-mem-with-reg/imm32/next -27651 _Primitive-xor-mem-with-reg: # (payload primitive) -27652 0x11/imm32/alloc-id:fake:payload -27653 # var1/reg <- xor var2 => 33/xor var2/rm32 var1/r32 -27654 0x11/imm32/alloc-id:fake -27655 _string-xor/imm32/name -27656 0x11/imm32/alloc-id:fake -27657 Single-int-var-in-mem/imm32/inouts -27658 0x11/imm32/alloc-id:fake -27659 Single-int-var-in-some-register/imm32/outputs -27660 0x11/imm32/alloc-id:fake -27661 _string_33_xor/imm32/subx-name -27662 1/imm32/rm32-is-first-inout -27663 3/imm32/r32-is-first-output -27664 0/imm32/no-imm32 -27665 0/imm32/no-imm8 -27666 0/imm32/no-disp32 -27667 0/imm32/no-xm32 -27668 0/imm32/no-x32 -27669 0x11/imm32/alloc-id:fake -27670 _Primitive-xor-lit-with-reg/imm32/next -27671 _Primitive-xor-lit-with-reg: # (payload primitive) -27672 0x11/imm32/alloc-id:fake:payload -27673 # var1/reg <- xor lit => 81 6/subop/xor var1/rm32 lit/imm32 -27674 0x11/imm32/alloc-id:fake -27675 _string-xor/imm32/name -27676 0x11/imm32/alloc-id:fake -27677 Single-lit-var/imm32/inouts -27678 0x11/imm32/alloc-id:fake -27679 Single-int-var-in-some-register/imm32/outputs -27680 0x11/imm32/alloc-id:fake -27681 _string_81_subop_xor/imm32/subx-name -27682 3/imm32/rm32-is-first-output -27683 0/imm32/no-r32 -27684 1/imm32/imm32-is-first-inout -27685 0/imm32/no-imm8 -27686 0/imm32/no-disp32 -27687 0/imm32/no-xm32 -27688 0/imm32/no-x32 -27689 0x11/imm32/alloc-id:fake -27690 _Primitive-xor-lit-with-mem/imm32/next -27691 _Primitive-xor-lit-with-mem: # (payload primitive) -27692 0x11/imm32/alloc-id:fake:payload -27693 # xor-with var1, lit => 81 6/subop/xor var1/rm32 lit/imm32 -27694 0x11/imm32/alloc-id:fake -27695 _string-xor-with/imm32/name -27696 0x11/imm32/alloc-id:fake -27697 Int-var-and-literal/imm32/inouts -27698 0/imm32/no-outputs -27699 0/imm32/no-outputs -27700 0x11/imm32/alloc-id:fake -27701 _string_81_subop_xor/imm32/subx-name -27702 1/imm32/rm32-is-first-inout -27703 0/imm32/no-r32 -27704 2/imm32/imm32-is-second-inout -27705 0/imm32/no-imm8 -27706 0/imm32/no-disp32 -27707 0/imm32/no-xm32 -27708 0/imm32/no-x32 -27709 0x11/imm32/alloc-id:fake -27710 _Primitive-shift-reg-left-by-lit/imm32/next -27711 _Primitive-shift-reg-left-by-lit: # (payload primitive) -27712 0x11/imm32/alloc-id:fake:payload -27713 # var1/reg <- shift-left lit => c1/shift 4/subop/left var1/rm32 lit/imm32 -27714 0x11/imm32/alloc-id:fake -27715 _string-shift-left/imm32/name -27716 0x11/imm32/alloc-id:fake -27717 Single-lit-var/imm32/inouts -27718 0x11/imm32/alloc-id:fake -27719 Single-int-var-in-some-register/imm32/outputs -27720 0x11/imm32/alloc-id:fake -27721 _string_c1_subop_shift_left/imm32/subx-name -27722 3/imm32/rm32-is-first-output -27723 0/imm32/no-r32 -27724 0/imm32/no-imm32 -27725 1/imm32/imm8-is-first-inout -27726 0/imm32/no-disp32 -27727 0/imm32/no-xm32 -27728 0/imm32/no-x32 -27729 0x11/imm32/alloc-id:fake -27730 _Primitive-shift-reg-right-by-lit/imm32/next -27731 _Primitive-shift-reg-right-by-lit: # (payload primitive) -27732 0x11/imm32/alloc-id:fake:payload -27733 # var1/reg <- shift-right lit => c1/shift 5/subop/right var1/rm32 lit/imm32 -27734 0x11/imm32/alloc-id:fake -27735 _string-shift-right/imm32/name -27736 0x11/imm32/alloc-id:fake -27737 Single-lit-var/imm32/inouts -27738 0x11/imm32/alloc-id:fake -27739 Single-int-var-in-some-register/imm32/outputs -27740 0x11/imm32/alloc-id:fake -27741 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name -27742 3/imm32/rm32-is-first-output -27743 0/imm32/no-r32 -27744 0/imm32/no-imm32 -27745 1/imm32/imm8-is-first-inout -27746 0/imm32/no-disp32 -27747 0/imm32/no-xm32 -27748 0/imm32/no-x32 -27749 0x11/imm32/alloc-id:fake -27750 _Primitive-shift-reg-right-signed-by-lit/imm32/next -27751 _Primitive-shift-reg-right-signed-by-lit: # (payload primitive) -27752 0x11/imm32/alloc-id:fake:payload -27753 # var1/reg <- shift-right-signed lit => c1/shift 7/subop/right-preserving-sign var1/rm32 lit/imm32 -27754 0x11/imm32/alloc-id:fake -27755 _string-shift-right-signed/imm32/name -27756 0x11/imm32/alloc-id:fake -27757 Single-lit-var/imm32/inouts -27758 0x11/imm32/alloc-id:fake -27759 Single-int-var-in-some-register/imm32/outputs -27760 0x11/imm32/alloc-id:fake -27761 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name -27762 3/imm32/rm32-is-first-output -27763 0/imm32/no-r32 -27764 0/imm32/no-imm32 -27765 1/imm32/imm8-is-first-inout -27766 0/imm32/no-disp32 -27767 0/imm32/no-xm32 -27768 0/imm32/no-x32 -27769 0x11/imm32/alloc-id:fake -27770 _Primitive-shift-mem-left-by-lit/imm32/next -27771 _Primitive-shift-mem-left-by-lit: # (payload primitive) -27772 0x11/imm32/alloc-id:fake:payload -27773 # shift-left var1, lit => c1/shift 4/subop/left var1/rm32 lit/imm32 -27774 0x11/imm32/alloc-id:fake -27775 _string-shift-left/imm32/name -27776 0x11/imm32/alloc-id:fake -27777 Int-var-and-literal/imm32/inouts -27778 0/imm32/no-outputs -27779 0/imm32/no-outputs -27780 0x11/imm32/alloc-id:fake -27781 _string_c1_subop_shift_left/imm32/subx-name -27782 1/imm32/rm32-is-first-inout -27783 0/imm32/no-r32 -27784 0/imm32/no-imm32 -27785 2/imm32/imm8-is-second-inout -27786 0/imm32/no-disp32 -27787 0/imm32/no-xm32 -27788 0/imm32/no-x32 -27789 0x11/imm32/alloc-id:fake -27790 _Primitive-shift-mem-right-by-lit/imm32/next -27791 _Primitive-shift-mem-right-by-lit: # (payload primitive) -27792 0x11/imm32/alloc-id:fake:payload -27793 # shift-right var1, lit => c1/shift 5/subop/right var1/rm32 lit/imm32 -27794 0x11/imm32/alloc-id:fake -27795 _string-shift-right/imm32/name -27796 0x11/imm32/alloc-id:fake -27797 Int-var-and-literal/imm32/inouts -27798 0/imm32/no-outputs -27799 0/imm32/no-outputs -27800 0x11/imm32/alloc-id:fake -27801 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name -27802 1/imm32/rm32-is-first-inout -27803 0/imm32/no-r32 -27804 0/imm32/no-imm32 -27805 2/imm32/imm8-is-second-inout -27806 0/imm32/no-disp32 -27807 0/imm32/no-xm32 -27808 0/imm32/no-x32 -27809 0x11/imm32/alloc-id:fake -27810 _Primitive-shift-mem-right-signed-by-lit/imm32/next -27811 _Primitive-shift-mem-right-signed-by-lit: # (payload primitive) -27812 0x11/imm32/alloc-id:fake:payload -27813 # shift-right-signed var1, lit => c1/shift 7/subop/right-preserving-sign var1/rm32 lit/imm32 -27814 0x11/imm32/alloc-id:fake -27815 _string-shift-right-signed/imm32/name -27816 0x11/imm32/alloc-id:fake -27817 Int-var-and-literal/imm32/inouts -27818 0/imm32/no-outputs -27819 0/imm32/no-outputs -27820 0x11/imm32/alloc-id:fake -27821 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name -27822 1/imm32/rm32-is-first-inout -27823 0/imm32/no-r32 -27824 0/imm32/no-imm32 -27825 2/imm32/imm8-is-second-inout -27826 0/imm32/no-disp32 -27827 0/imm32/no-xm32 -27828 0/imm32/no-x32 -27829 0x11/imm32/alloc-id:fake -27830 _Primitive-copy-to-eax/imm32/next -27831 # - copy -27832 _Primitive-copy-to-eax: # (payload primitive) -27833 0x11/imm32/alloc-id:fake:payload -27834 # var/eax <- copy lit => b8/copy-to-eax lit/imm32 -27835 0x11/imm32/alloc-id:fake -27836 _string-copy/imm32/name -27837 0x11/imm32/alloc-id:fake -27838 Single-lit-var/imm32/inouts -27839 0x11/imm32/alloc-id:fake -27840 Single-int-var-in-eax/imm32/outputs -27841 0x11/imm32/alloc-id:fake -27842 _string_b8_copy_to_eax/imm32/subx-name -27843 0/imm32/no-rm32 -27844 0/imm32/no-r32 -27845 1/imm32/imm32-is-first-inout -27846 0/imm32/no-imm8 -27847 0/imm32/no-disp32 -27848 0/imm32/no-xm32 -27849 0/imm32/no-x32 -27850 0x11/imm32/alloc-id:fake -27851 _Primitive-copy-to-ecx/imm32/next -27852 _Primitive-copy-to-ecx: # (payload primitive) -27853 0x11/imm32/alloc-id:fake:payload -27854 # var/ecx <- copy lit => b9/copy-to-ecx lit/imm32 -27855 0x11/imm32/alloc-id:fake -27856 _string-copy/imm32/name -27857 0x11/imm32/alloc-id:fake -27858 Single-lit-var/imm32/inouts -27859 0x11/imm32/alloc-id:fake -27860 Single-int-var-in-ecx/imm32/outputs -27861 0x11/imm32/alloc-id:fake -27862 _string_b9_copy_to_ecx/imm32/subx-name -27863 0/imm32/no-rm32 -27864 0/imm32/no-r32 -27865 1/imm32/imm32-is-first-inout -27866 0/imm32/no-imm8 -27867 0/imm32/no-disp32 -27868 0/imm32/no-xm32 -27869 0/imm32/no-x32 -27870 0x11/imm32/alloc-id:fake -27871 _Primitive-copy-to-edx/imm32/next -27872 _Primitive-copy-to-edx: # (payload primitive) -27873 0x11/imm32/alloc-id:fake:payload -27874 # var/edx <- copy lit => ba/copy-to-edx lit/imm32 -27875 0x11/imm32/alloc-id:fake -27876 _string-copy/imm32/name -27877 0x11/imm32/alloc-id:fake -27878 Single-lit-var/imm32/inouts -27879 0x11/imm32/alloc-id:fake -27880 Single-int-var-in-edx/imm32/outputs -27881 0x11/imm32/alloc-id:fake -27882 _string_ba_copy_to_edx/imm32/subx-name -27883 0/imm32/no-rm32 -27884 0/imm32/no-r32 -27885 1/imm32/imm32-is-first-inout -27886 0/imm32/no-imm8 -27887 0/imm32/no-disp32 -27888 0/imm32/no-xm32 -27889 0/imm32/no-x32 -27890 0x11/imm32/alloc-id:fake -27891 _Primitive-copy-to-ebx/imm32/next -27892 _Primitive-copy-to-ebx: # (payload primitive) -27893 0x11/imm32/alloc-id:fake:payload -27894 # var/ebx <- copy lit => bb/copy-to-ebx lit/imm32 -27895 0x11/imm32/alloc-id:fake -27896 _string-copy/imm32/name -27897 0x11/imm32/alloc-id:fake -27898 Single-lit-var/imm32/inouts -27899 0x11/imm32/alloc-id:fake -27900 Single-int-var-in-ebx/imm32/outputs -27901 0x11/imm32/alloc-id:fake -27902 _string_bb_copy_to_ebx/imm32/subx-name -27903 0/imm32/no-rm32 -27904 0/imm32/no-r32 -27905 1/imm32/imm32-is-first-inout -27906 0/imm32/no-imm8 -27907 0/imm32/no-disp32 -27908 0/imm32/no-xm32 -27909 0/imm32/no-x32 -27910 0x11/imm32/alloc-id:fake -27911 _Primitive-copy-to-esi/imm32/next -27912 _Primitive-copy-to-esi: # (payload primitive) -27913 0x11/imm32/alloc-id:fake:payload -27914 # var/esi <- copy lit => be/copy-to-esi lit/imm32 -27915 0x11/imm32/alloc-id:fake -27916 _string-copy/imm32/name -27917 0x11/imm32/alloc-id:fake -27918 Single-lit-var/imm32/inouts -27919 0x11/imm32/alloc-id:fake -27920 Single-int-var-in-esi/imm32/outputs -27921 0x11/imm32/alloc-id:fake -27922 _string_be_copy_to_esi/imm32/subx-name -27923 0/imm32/no-rm32 -27924 0/imm32/no-r32 -27925 1/imm32/imm32-is-first-inout -27926 0/imm32/no-imm8 -27927 0/imm32/no-disp32 -27928 0/imm32/no-xm32 -27929 0/imm32/no-x32 -27930 0x11/imm32/alloc-id:fake -27931 _Primitive-copy-to-edi/imm32/next -27932 _Primitive-copy-to-edi: # (payload primitive) -27933 0x11/imm32/alloc-id:fake:payload -27934 # var/edi <- copy lit => bf/copy-to-edi lit/imm32 -27935 0x11/imm32/alloc-id:fake -27936 _string-copy/imm32/name -27937 0x11/imm32/alloc-id:fake -27938 Single-lit-var/imm32/inouts -27939 0x11/imm32/alloc-id:fake -27940 Single-int-var-in-edi/imm32/outputs -27941 0x11/imm32/alloc-id:fake -27942 _string_bf_copy_to_edi/imm32/subx-name -27943 0/imm32/no-rm32 -27944 0/imm32/no-r32 -27945 1/imm32/imm32-is-first-inout -27946 0/imm32/no-imm8 -27947 0/imm32/no-disp32 -27948 0/imm32/no-xm32 -27949 0/imm32/no-x32 -27950 0x11/imm32/alloc-id:fake -27951 _Primitive-copy-reg-to-reg/imm32/next -27952 _Primitive-copy-reg-to-reg: # (payload primitive) -27953 0x11/imm32/alloc-id:fake:payload -27954 # var1/reg <- copy var2/reg => 89/<- var1/rm32 var2/r32 -27955 0x11/imm32/alloc-id:fake -27956 _string-copy/imm32/name -27957 0x11/imm32/alloc-id:fake -27958 Single-int-var-in-some-register/imm32/inouts -27959 0x11/imm32/alloc-id:fake -27960 Single-int-var-in-some-register/imm32/outputs -27961 0x11/imm32/alloc-id:fake -27962 _string_89_<-/imm32/subx-name -27963 3/imm32/rm32-is-first-output -27964 1/imm32/r32-is-first-inout -27965 0/imm32/no-imm32 -27966 0/imm32/no-imm8 -27967 0/imm32/no-disp32 -27968 0/imm32/no-xm32 -27969 0/imm32/no-x32 -27970 0x11/imm32/alloc-id:fake -27971 _Primitive-copy-reg-to-mem/imm32/next -27972 _Primitive-copy-reg-to-mem: # (payload primitive) -27973 0x11/imm32/alloc-id:fake:payload -27974 # copy-to var1 var2/reg => 89/<- var1 var2/r32 -27975 0x11/imm32/alloc-id:fake -27976 _string-copy-to/imm32/name -27977 0x11/imm32/alloc-id:fake -27978 Two-args-int-stack-int-reg/imm32/inouts -27979 0/imm32/no-outputs -27980 0/imm32/no-outputs -27981 0x11/imm32/alloc-id:fake -27982 _string_89_<-/imm32/subx-name -27983 1/imm32/rm32-is-first-inout -27984 2/imm32/r32-is-second-inout -27985 0/imm32/no-imm32 -27986 0/imm32/no-imm8 -27987 0/imm32/no-disp32 -27988 0/imm32/no-xm32 -27989 0/imm32/no-x32 -27990 0x11/imm32/alloc-id:fake -27991 _Primitive-copy-mem-to-reg/imm32/next -27992 _Primitive-copy-mem-to-reg: # (payload primitive) -27993 0x11/imm32/alloc-id:fake:payload -27994 # var1/reg <- copy var2 => 8b/-> var2/rm32 var1/r32 -27995 0x11/imm32/alloc-id:fake -27996 _string-copy/imm32/name -27997 0x11/imm32/alloc-id:fake -27998 Single-int-var-in-mem/imm32/inouts -27999 0x11/imm32/alloc-id:fake -28000 Single-int-var-in-some-register/imm32/outputs -28001 0x11/imm32/alloc-id:fake -28002 _string_8b_->/imm32/subx-name -28003 1/imm32/rm32-is-first-inout -28004 3/imm32/r32-is-first-output -28005 0/imm32/no-imm32 -28006 0/imm32/no-imm8 -28007 0/imm32/no-disp32 -28008 0/imm32/no-xm32 -28009 0/imm32/no-x32 -28010 0x11/imm32/alloc-id:fake -28011 _Primitive-copy-lit-to-reg/imm32/next -28012 _Primitive-copy-lit-to-reg: # (payload primitive) -28013 0x11/imm32/alloc-id:fake:payload -28014 # var1/reg <- copy lit => c7 0/subop/copy var1/rm32 lit/imm32 -28015 0x11/imm32/alloc-id:fake -28016 _string-copy/imm32/name -28017 0x11/imm32/alloc-id:fake -28018 Single-lit-var/imm32/inouts -28019 0x11/imm32/alloc-id:fake -28020 Single-int-var-in-some-register/imm32/outputs -28021 0x11/imm32/alloc-id:fake -28022 _string_c7_subop_copy/imm32/subx-name -28023 3/imm32/rm32-is-first-output -28024 0/imm32/no-r32 -28025 1/imm32/imm32-is-first-inout -28026 0/imm32/no-imm8 -28027 0/imm32/no-disp32 -28028 0/imm32/no-xm32 -28029 0/imm32/no-x32 -28030 0x11/imm32/alloc-id:fake -28031 _Primitive-copy-lit-to-mem/imm32/next -28032 _Primitive-copy-lit-to-mem: # (payload primitive) -28033 0x11/imm32/alloc-id:fake:payload -28034 # copy-to var1, lit => c7 0/subop/copy var1/rm32 lit/imm32 -28035 0x11/imm32/alloc-id:fake -28036 _string-copy-to/imm32/name -28037 0x11/imm32/alloc-id:fake -28038 Int-var-and-literal/imm32/inouts -28039 0/imm32/no-outputs -28040 0/imm32/no-outputs -28041 0x11/imm32/alloc-id:fake -28042 _string_c7_subop_copy/imm32/subx-name -28043 1/imm32/rm32-is-first-inout -28044 0/imm32/no-r32 -28045 2/imm32/imm32-is-second-inout -28046 0/imm32/no-imm8 -28047 0/imm32/no-disp32 -28048 0/imm32/no-xm32 -28049 0/imm32/no-x32 -28050 0x11/imm32/alloc-id:fake -28051 _Primitive-copy-byte-from-reg/imm32/next -28052 # - copy byte -28053 _Primitive-copy-byte-from-reg: -28054 0x11/imm32/alloc-id:fake:payload -28055 # var/reg <- copy-byte var2/reg2 => 8a/byte-> %var2 var/r32 -28056 0x11/imm32/alloc-id:fake -28057 _string-copy-byte/imm32/name +26653 # var t/eax: (addr type-tree) +26654 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +26655 # if t == 0 abort +26656 3d/compare-eax-with 0/imm32 +26657 0f 84/jump-if-== $array-element-type-id:error0/disp32 +26658 # if t->is-atom? abort +26659 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +26660 0f 85/jump-if-!= $array-element-type-id:error1/disp32 +26661 # if (t->left == addr) t = t->right +26662 { +26663 50/push-eax +26664 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +26665 (is-simple-mu-type? %eax 2) # addr => eax +26666 3d/compare-eax-with 0/imm32/false +26667 58/pop-to-eax +26668 74/jump-if-= break/disp8 +26669 $array-element-type-id:skip-addr: +26670 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +26671 } +26672 # if t == 0 abort +26673 3d/compare-eax-with 0/imm32 +26674 0f 84/jump-if-= $array-element-type-id:error2/disp32 +26675 # if t->is-atom? abort +26676 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +26677 0f 85/jump-if-!= $array-element-type-id:error2/disp32 +26678 # if t->left != array abort +26679 { +26680 50/push-eax +26681 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +26682 (is-simple-mu-type? %eax 3) # array => eax +26683 3d/compare-eax-with 0/imm32/false +26684 58/pop-to-eax +26685 $array-element-type-id:no-array: +26686 0f 84/jump-if-= $array-element-type-id:error2/disp32 +26687 } +26688 $array-element-type-id:skip-array: +26689 # t = t->right +26690 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +26691 # if t == 0 abort +26692 3d/compare-eax-with 0/imm32 +26693 0f 84/jump-if-= $array-element-type-id:error2/disp32 +26694 # if t->is-atom? abort +26695 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +26696 0f 85/jump-if-!= $array-element-type-id:error2/disp32 +26697 # t = t->left +26698 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +26699 # if (!t->is-atom?) t = t->left # TODO: assumes array element size can be determined from just first word of array element type +26700 # if (t->is-atom == false) t = lookup(t->left) +26701 { +26702 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +26703 75/jump-if-!= break/disp8 +26704 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +26705 } +26706 # return t->value +26707 8b/-> *(eax+4) 0/r32/eax # Type-tree-value +26708 $array-element-type-id:end: +26709 # . epilogue +26710 89/<- %esp 5/r32/ebp +26711 5d/pop-to-ebp +26712 c3/return +26713 +26714 $array-element-type-id:error0: +26715 (write-buffered *(ebp+0xc) "array-element-type-id: var '") +26716 50/push-eax +26717 8b/-> *(ebp+8) 0/r32/eax +26718 (lookup *eax *(eax+4)) # Var-name Var-name => eax +26719 (write-buffered *(ebp+0xc) %eax) +26720 58/pop-to-eax +26721 (write-buffered *(ebp+0xc) "' has no type\n") +26722 (flush *(ebp+0xc)) +26723 (stop *(ebp+0x10) 1) +26724 # never gets here +26725 +26726 $array-element-type-id:error1: +26727 (write-buffered *(ebp+0xc) "array-element-type-id: var '") +26728 50/push-eax +26729 8b/-> *(ebp+8) 0/r32/eax +26730 (lookup *eax *(eax+4)) # Var-name Var-name => eax +26731 (write-buffered *(ebp+0xc) %eax) +26732 58/pop-to-eax +26733 (write-buffered *(ebp+0xc) "' has atomic type ") +26734 (write-int32-hex-buffered *(ebp+0xc) *(eax+4)) # Type-tree-value +26735 (write-buffered *(ebp+0xc) Newline) +26736 (flush *(ebp+0xc)) +26737 (stop *(ebp+0x10) 1) +26738 # never gets here +26739 +26740 $array-element-type-id:error2: +26741 (write-buffered *(ebp+0xc) "array-element-type-id: var '") +26742 50/push-eax +26743 8b/-> *(ebp+8) 0/r32/eax +26744 (lookup *eax *(eax+4)) # Var-name Var-name => eax +26745 (write-buffered *(ebp+0xc) %eax) +26746 58/pop-to-eax +26747 (write-buffered *(ebp+0xc) "' has non-array type\n") +26748 (flush *(ebp+0xc)) +26749 (stop *(ebp+0x10) 1) +26750 # never gets here +26751 +26752 size-of-type-id-as-array-element: # t: type-id -> result/eax: int +26753 # . prologue +26754 55/push-ebp +26755 89/<- %ebp 4/r32/esp +26756 # eax = t +26757 8b/-> *(ebp+8) 0/r32/eax +26758 # if t is 'byte', size is 1 +26759 3d/compare-eax-and 8/imm32/byte +26760 { +26761 75/jump-if-!= break/disp8 +26762 b8/copy-to-eax 1/imm32 +26763 eb/jump $size-of-type-id-as-array-element:end/disp8 +26764 } +26765 # otherwise proceed as usual +26766 (size-of-type-id %eax) # => eax +26767 $size-of-type-id-as-array-element:end: +26768 # . epilogue +26769 89/<- %esp 5/r32/ebp +26770 5d/pop-to-ebp +26771 c3/return +26772 +26773 emit-save-size-to: # out: (addr buffered-file), base: (addr var), outreg: (addr array byte) +26774 # . prologue +26775 55/push-ebp +26776 89/<- %ebp 4/r32/esp +26777 # . save registers +26778 50/push-eax +26779 53/push-ebx +26780 # ebx = base +26781 8b/-> *(ebp+0xc) 3/r32/ebx +26782 (emit-indent *(ebp+8) *Curr-block-depth) +26783 (write-buffered *(ebp+8) "8b/-> *") +26784 # if base is an (addr array ...) in a register +26785 { +26786 81 7/subop/compare *(ebx+0x18)) 0/imm32 # Var-register +26787 74/jump-if-= break/disp8 +26788 $emit-save-size-to:emit-base-from-register: +26789 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +26790 (write-buffered *(ebp+8) %eax) +26791 eb/jump $emit-save-size-to:emit-output/disp8 +26792 } +26793 # otherwise if base is an (array ...) on the stack +26794 { +26795 81 7/subop/compare *(ebx+0x14)) 0/imm32 # Var-offset +26796 74/jump-if-= break/disp8 +26797 $emit-save-size-to:emit-base-from-stack: +26798 (write-buffered *(ebp+8) "(ebp+") +26799 (write-int32-hex-buffered *(ebp+8) *(ebx+0x14)) # Var-offset +26800 (write-buffered *(ebp+8) ")") +26801 } +26802 $emit-save-size-to:emit-output: +26803 (write-buffered *(ebp+8) " ") +26804 (get Mu-registers *(ebp+0x10) 0xc "Mu-registers") # => eax +26805 (write-int32-hex-buffered *(ebp+8) *eax) +26806 (write-buffered *(ebp+8) "/r32\n") +26807 $emit-save-size-to:end: +26808 # . restore registers +26809 5b/pop-to-ebx +26810 58/pop-to-eax +26811 # . epilogue +26812 89/<- %esp 5/r32/ebp +26813 5d/pop-to-ebp +26814 c3/return +26815 +26816 emit-divide-by-shift-right: # out: (addr buffered-file), reg: (addr array byte), size: int +26817 # . prologue +26818 55/push-ebp +26819 89/<- %ebp 4/r32/esp +26820 # . save registers +26821 50/push-eax +26822 # +26823 (emit-indent *(ebp+8) *Curr-block-depth) +26824 (write-buffered *(ebp+8) "c1/shift 5/subop/>> %") +26825 (write-buffered *(ebp+8) *(ebp+0xc)) +26826 (write-buffered *(ebp+8) Space) +26827 (num-shift-rights *(ebp+0x10)) # => eax +26828 (write-int32-hex-buffered *(ebp+8) %eax) +26829 (write-buffered *(ebp+8) "/imm8\n") +26830 $emit-divide-by-shift-right:end: +26831 # . restore registers +26832 58/pop-to-eax +26833 # . epilogue +26834 89/<- %esp 5/r32/ebp +26835 5d/pop-to-ebp +26836 c3/return +26837 +26838 translate-mu-index-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +26839 # . prologue +26840 55/push-ebp +26841 89/<- %ebp 4/r32/esp +26842 # . save registers +26843 51/push-ecx +26844 # ecx = stmt +26845 8b/-> *(ebp+0xc) 1/r32/ecx +26846 # var base/ecx: (addr var) = stmt->inouts[0] +26847 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +26848 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +26849 89/<- %ecx 0/r32/eax +26850 # if (var->register) do one thing +26851 { +26852 81 7/subop/compare *(ecx+0x18) 0/imm32 # Var-register +26853 74/jump-if-= break/disp8 +26854 # TODO: ensure there's no dereference +26855 (translate-mu-index-stmt-with-array-in-register *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +26856 eb/jump $translate-mu-index-stmt:end/disp8 +26857 } +26858 # if (var->offset) do a different thing +26859 { +26860 81 7/subop/compare *(ecx+0x14) 0/imm32 # Var-offset +26861 74/jump-if-= break/disp8 +26862 # TODO: ensure there's no dereference +26863 (translate-mu-index-stmt-with-array-on-stack *(ebp+8) *(ebp+0xc) *(ebp+0x10) *(ebp+0x14)) +26864 eb/jump $translate-mu-index-stmt:end/disp8 +26865 } +26866 $translate-mu-index-stmt:end: +26867 # . restore registers +26868 59/pop-to-ecx +26869 # . epilogue +26870 89/<- %esp 5/r32/ebp +26871 5d/pop-to-ebp +26872 c3/return +26873 +26874 $translate-mu-index-stmt-with-array:error1: +26875 (write-buffered *(ebp+0x10) "couldn't translate an index instruction. second (index) input must either lie in a register or be a literal\n") +26876 (flush *(ebp+0x10)) +26877 (stop *(ebp+0x14) 1) +26878 # never gets here +26879 +26880 $translate-mu-index-stmt-with-array:error2: +26881 (write-buffered *(ebp+0x10) "couldn't translate an index instruction. second (index) input when in a register must be an int or offset\n") +26882 (flush *(ebp+0x10)) +26883 (stop *(ebp+0x14) 1) +26884 # never gets here +26885 +26886 translate-mu-index-stmt-with-array-in-register: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +26887 # . prologue +26888 55/push-ebp +26889 89/<- %ebp 4/r32/esp +26890 # . save registers +26891 50/push-eax +26892 51/push-ecx +26893 52/push-edx +26894 53/push-ebx +26895 # +26896 (emit-indent *(ebp+8) *Curr-block-depth) +26897 (write-buffered *(ebp+8) "8d/copy-address *(") +26898 # TODO: ensure inouts[0] is in a register and not dereferenced +26899 $translate-mu-index-stmt-with-array-in-register:emit-base: +26900 # ecx = stmt +26901 8b/-> *(ebp+0xc) 1/r32/ecx +26902 # var base/ebx: (addr var) = inouts[0] +26903 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +26904 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +26905 89/<- %ebx 0/r32/eax +26906 # print base->register " + " +26907 (lookup *(ebx+0x18) *(ebx+0x1c)) # Var-register Var-register => eax +26908 (write-buffered *(ebp+8) %eax) +26909 (write-buffered *(ebp+8) " + ") +26910 # var index/edx: (addr var) = inouts[1] +26911 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +26912 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +26913 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +26914 89/<- %edx 0/r32/eax +26915 # if index->register +26916 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register +26917 { +26918 0f 84/jump-if-= break/disp32 +26919 $translate-mu-index-stmt-with-array-in-register:emit-register-index: +26920 # if index is an int +26921 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +26922 (is-simple-mu-type? %eax 1) # int => eax +26923 3d/compare-eax-and 0/imm32/false +26924 { +26925 0f 84/jump-if-= break/disp32 +26926 $translate-mu-index-stmt-with-array-in-register:emit-int-register-index: +26927 # print index->register "<<" log2(array-element-size(base)) " + 4) " +26928 # . index->register "<<" +26929 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +26930 (write-buffered *(ebp+8) %eax) +26931 (write-buffered *(ebp+8) "<<") +26932 # . log2(array-element-size(base->type)) +26933 # TODO: ensure size is a power of 2 +26934 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax +26935 (num-shift-rights %eax) # => eax +26936 (write-int32-hex-buffered *(ebp+8) %eax) +26937 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-register-index-done/disp32 +26938 } +26939 # if index->type is any other atom, abort +26940 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +26941 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +26942 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 +26943 # if index has type (offset ...) +26944 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +26945 (is-simple-mu-type? %eax 7) # => eax +26946 3d/compare-eax-and 0/imm32/false +26947 { +26948 0f 84/jump-if-= break/disp32 +26949 # print index->register +26950 $translate-mu-index-stmt-with-array-in-register:emit-offset-register-index: +26951 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +26952 (write-buffered *(ebp+8) %eax) +26953 } +26954 $translate-mu-index-stmt-with-array-in-register:emit-register-index-done: +26955 (write-buffered *(ebp+8) " + 4) ") +26956 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 +26957 } +26958 # otherwise if index is a literal +26959 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +26960 (is-simple-mu-type? %eax 0) # => eax +26961 3d/compare-eax-and 0/imm32/false +26962 { +26963 0f 84/jump-if-= break/disp32 +26964 $translate-mu-index-stmt-with-array-in-register:emit-literal-index: +26965 # var index-value/edx: int = parse-hex-int(index->name) +26966 (lookup *edx *(edx+4)) # Var-name Var-name => eax +26967 (parse-hex-int %eax) # => eax +26968 89/<- %edx 0/r32/eax +26969 # offset = idx-value * array-element-size(base->type) +26970 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax +26971 f7 4/subop/multiply-into-edx-eax %edx # clobbers edx +26972 # offset += 4 for array size +26973 05/add-to-eax 4/imm32 +26974 # TODO: check edx for overflow +26975 # print offset +26976 (write-int32-hex-buffered *(ebp+8) %eax) +26977 (write-buffered *(ebp+8) ") ") +26978 e9/jump $translate-mu-index-stmt-with-array-in-register:emit-output/disp32 +26979 } +26980 # otherwise abort +26981 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 +26982 $translate-mu-index-stmt-with-array-in-register:emit-output: +26983 # outputs[0] "/r32" +26984 8b/-> *(ebp+0xc) 1/r32/ecx +26985 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +26986 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +26987 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +26988 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) +26989 (write-int32-hex-buffered *(ebp+8) *eax) +26990 (write-buffered *(ebp+8) "/r32\n") +26991 $translate-mu-index-stmt-with-array-in-register:end: +26992 # . restore registers +26993 5b/pop-to-ebx +26994 5a/pop-to-edx +26995 59/pop-to-ecx +26996 58/pop-to-eax +26997 # . epilogue +26998 89/<- %esp 5/r32/ebp +26999 5d/pop-to-ebp +27000 c3/return +27001 +27002 translate-mu-index-stmt-with-array-on-stack: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +27003 # . prologue +27004 55/push-ebp +27005 89/<- %ebp 4/r32/esp +27006 # . save registers +27007 50/push-eax +27008 51/push-ecx +27009 52/push-edx +27010 53/push-ebx +27011 # +27012 (emit-indent *(ebp+8) *Curr-block-depth) +27013 (write-buffered *(ebp+8) "8d/copy-address *(ebp + ") +27014 # var curr/edx: (addr stmt-var) = lookup(stmt->inouts) +27015 8b/-> *(ebp+0xc) 0/r32/eax +27016 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27017 89/<- %edx 0/r32/eax +27018 # var base/ecx: (addr var) = lookup(curr->value) +27019 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27020 89/<- %ecx 0/r32/eax +27021 # var curr2/eax: (addr stmt-var) = lookup(curr->next) +27022 (lookup *(edx+8) *(edx+0xc)) # Stmt-var-next Stmt-var-next => eax +27023 # var index/edx: (handle var) = curr2->value +27024 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27025 89/<- %edx 0/r32/eax +27026 # if index->register +27027 81 7/subop/compare *(edx+0x18) 0/imm32 # Var-register +27028 { +27029 0f 84/jump-if-= break/disp32 +27030 $translate-mu-index-stmt-with-array-on-stack:emit-register-index: +27031 # if index is an int +27032 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +27033 (is-simple-mu-type? %eax 1) # int => eax +27034 3d/compare-eax-and 0/imm32/false +27035 { +27036 0f 84/jump-if-= break/disp32 +27037 $translate-mu-index-stmt-with-array-on-stack:emit-int-register-index: +27038 # print index->register "<<" log2(array-element-size(base)) " + " base->offset+4 +27039 # . inouts[1]->register "<<" +27040 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +27041 (write-buffered *(ebp+8) %eax) +27042 (write-buffered *(ebp+8) "<<") +27043 # . log2(array-element-size(base)) +27044 # TODO: ensure size is a power of 2 +27045 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14)) # => eax +27046 (num-shift-rights %eax) # => eax +27047 (write-int32-hex-buffered *(ebp+8) %eax) +27048 # +27049 (write-buffered *(ebp+8) " + ") +27050 # +27051 8b/-> *(ecx+0x14) 0/r32/eax # Var-offset +27052 05/add-to-eax 4/imm32 # for array length +27053 (write-int32-hex-buffered *(ebp+8) %eax) +27054 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done/disp32 +27055 } +27056 # if index->type is any other atom, abort +27057 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +27058 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +27059 0f 85/jump-if-!= $translate-mu-index-stmt-with-array:error2/disp32 +27060 # if index has type (offset ...) +27061 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +27062 (is-simple-mu-type? %eax 7) # => eax +27063 3d/compare-eax-and 0/imm32/false +27064 { +27065 0f 84/jump-if-= break/disp32 +27066 # print index->register +27067 $translate-mu-index-stmt-with-array-on-stack:emit-offset-register-index: +27068 (lookup *(edx+0x18) *(edx+0x1c)) # Var-register Var-register => eax +27069 (write-buffered *(ebp+8) %eax) +27070 } +27071 $translate-mu-index-stmt-with-array-on-stack:emit-register-index-done: +27072 (write-buffered *(ebp+8) ") ") +27073 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 +27074 } +27075 # otherwise if index is a literal +27076 (lookup *(edx+8) *(edx+0xc)) # Var-type Var-type => eax +27077 (is-simple-mu-type? %eax 0) # => eax +27078 3d/compare-eax-and 0/imm32/false +27079 { +27080 0f 84/jump-if-= break/disp32 +27081 $translate-mu-index-stmt-with-array-on-stack:emit-literal-index: +27082 # var idx-value/edx: int = parse-hex-int(index->name) +27083 (lookup *edx *(edx+4)) # Var-name Var-name => eax +27084 (parse-hex-int %eax) # Var-name => eax +27085 89/<- %edx 0/r32/eax +27086 # offset = idx-value * array-element-size(base) +27087 (array-element-size %ecx *(ebp+0x10) *(ebp+0x14)) # => eax +27088 f7 4/subop/multiply-into-edx-eax %edx # clobbers edx +27089 # offset += base->offset +27090 03/add *(ecx+0x14) 0/r32/eax # Var-offset +27091 # offset += 4 for array size +27092 05/add-to-eax 4/imm32 +27093 # TODO: check edx for overflow +27094 # print offset +27095 (write-int32-hex-buffered *(ebp+8) %eax) +27096 (write-buffered *(ebp+8) ") ") +27097 e9/jump $translate-mu-index-stmt-with-array-on-stack:emit-output/disp32 +27098 } +27099 # otherwise abort +27100 e9/jump $translate-mu-index-stmt-with-array:error1/disp32 +27101 $translate-mu-index-stmt-with-array-on-stack:emit-output: +27102 # outputs[0] "/r32" +27103 8b/-> *(ebp+0xc) 0/r32/eax +27104 (lookup *(eax+0x14) *(eax+0x18)) # Stmt1-outputs Stmt1-outputs => eax +27105 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27106 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +27107 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) +27108 (write-int32-hex-buffered *(ebp+8) *eax) +27109 (write-buffered *(ebp+8) "/r32\n") +27110 $translate-mu-index-stmt-with-array-on-stack:end: +27111 # . restore registers +27112 5b/pop-to-ebx +27113 5a/pop-to-edx +27114 59/pop-to-ecx +27115 58/pop-to-eax +27116 # . epilogue +27117 89/<- %esp 5/r32/ebp +27118 5d/pop-to-ebp +27119 c3/return +27120 +27121 translate-mu-compute-index-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +27122 # . prologue +27123 55/push-ebp +27124 89/<- %ebp 4/r32/esp +27125 # . save registers +27126 50/push-eax +27127 51/push-ecx +27128 52/push-edx +27129 53/push-ebx +27130 # +27131 (emit-indent *(ebp+8) *Curr-block-depth) +27132 (write-buffered *(ebp+8) "69/multiply") +27133 # ecx = stmt +27134 8b/-> *(ebp+0xc) 1/r32/ecx +27135 # var first-inout/ebx: (addr stmt-var) = stmt->inouts[0] +27136 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27137 89/<- %ebx 0/r32/eax +27138 $translate-mu-compute-index-stmt:emit-index: +27139 (lookup *(ebx+8) *(ebx+0xc)) # Stmt-var-next Stmt-var-next => eax +27140 (emit-subx-var-as-rm32 *(ebp+8) %eax) +27141 (write-buffered *(ebp+8) Space) +27142 $translate-mu-compute-index-stmt:emit-elem-size: +27143 # var base/ebx: (addr var) +27144 (lookup *ebx *(ebx+4)) # Stmt-var-value Stmt-var-value => eax +27145 89/<- %ebx 0/r32/eax +27146 # print array-element-size(base) +27147 (array-element-size %ebx *(ebp+0x10) *(ebp+0x14)) # => eax +27148 (write-int32-hex-buffered *(ebp+8) %eax) +27149 (write-buffered *(ebp+8) "/imm32 ") +27150 $translate-mu-compute-index-stmt:emit-output: +27151 # outputs[0] "/r32" +27152 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +27153 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27154 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +27155 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) +27156 (write-int32-hex-buffered *(ebp+8) *eax) +27157 (write-buffered *(ebp+8) "/r32\n") +27158 $translate-mu-compute-index-stmt:end: +27159 # . restore registers +27160 5b/pop-to-ebx +27161 5a/pop-to-edx +27162 59/pop-to-ecx +27163 58/pop-to-eax +27164 # . epilogue +27165 89/<- %esp 5/r32/ebp +27166 5d/pop-to-ebp +27167 c3/return +27168 +27169 translate-mu-get-stmt: # out: (addr buffered-file), stmt: (addr stmt) +27170 # . prologue +27171 55/push-ebp +27172 89/<- %ebp 4/r32/esp +27173 # . save registers +27174 50/push-eax +27175 51/push-ecx +27176 52/push-edx +27177 # +27178 (emit-indent *(ebp+8) *Curr-block-depth) +27179 (write-buffered *(ebp+8) "8d/copy-address ") +27180 # ecx = stmt +27181 8b/-> *(ebp+0xc) 1/r32/ecx +27182 # var offset/edx: int = get offset of stmt +27183 (mu-get-offset %ecx) # => eax +27184 89/<- %edx 0/r32/eax +27185 # var base/eax: (addr var) = stmt->inouts->value +27186 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27187 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27188 # if base is in a register +27189 81 7/subop/compare *(eax+0x18) 0/imm32 # Var-register +27190 { +27191 0f 84/jump-if-= break/disp32 +27192 $translate-mu-get-stmt:emit-register-input: +27193 # emit "*(" base->register " + " offset ") " +27194 (write-buffered *(ebp+8) "*(") +27195 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +27196 (write-buffered *(ebp+8) %eax) +27197 (write-buffered *(ebp+8) " + ") +27198 (write-int32-hex-buffered *(ebp+8) %edx) +27199 (write-buffered *(ebp+8) ") ") +27200 e9/jump $translate-mu-get-stmt:emit-output/disp32 +27201 } +27202 # otherwise base is on the stack +27203 { +27204 $translate-mu-get-stmt:emit-stack-input: +27205 # emit "*(ebp + " inouts[0]->stack-offset + offset ") " +27206 (write-buffered *(ebp+8) "*(ebp+") +27207 03/add *(eax+0x14) 2/r32/edx # Var-offset +27208 (write-int32-hex-buffered *(ebp+8) %edx) +27209 (write-buffered *(ebp+8) ") ") +27210 eb/jump $translate-mu-get-stmt:emit-output/disp8 +27211 } +27212 $translate-mu-get-stmt:emit-output: +27213 # var output/eax: (addr var) = stmt->outputs->value +27214 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +27215 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27216 # emit offset->register "/r32" +27217 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +27218 (get Mu-registers %eax 0xc "Mu-registers") # => eax: (addr int) +27219 (write-int32-hex-buffered *(ebp+8) *eax) +27220 (write-buffered *(ebp+8) "/r32\n") +27221 $translate-mu-get-stmt:end: +27222 # . restore registers +27223 5a/pop-to-edx +27224 59/pop-to-ecx +27225 58/pop-to-eax +27226 # . epilogue +27227 89/<- %esp 5/r32/ebp +27228 5d/pop-to-ebp +27229 c3/return +27230 +27231 translate-mu-copy-object-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +27232 # . prologue +27233 55/push-ebp +27234 89/<- %ebp 4/r32/esp +27235 # . save registers +27236 50/push-eax +27237 # +27238 (emit-indent *(ebp+8) *Curr-block-depth) +27239 (write-buffered *(ebp+8) "(copy-bytes") +27240 # eax = stmt +27241 8b/-> *(ebp+0xc) 0/r32/eax +27242 # var first-inout/eax: (addr stmt-var) = stmt->inouts[0] +27243 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27244 (emit-subx-call-operand *(ebp+8) %eax) +27245 # var second-inout/eax: (addr stmt-var) = stmt->inouts[1] +27246 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +27247 (emit-subx-call-operand *(ebp+8) %eax) +27248 # emit size of inouts +27249 (write-buffered *(ebp+8) Space) +27250 (addr-payload-size %eax *(ebp+0x10) *(ebp+0x14)) # => eax +27251 (write-int32-hex-buffered *(ebp+8) %eax) +27252 (write-buffered *(ebp+8) ")\n") +27253 $translate-mu-copy-object-stmt:end: +27254 # . restore registers +27255 58/pop-to-eax +27256 # . epilogue +27257 89/<- %esp 5/r32/ebp +27258 5d/pop-to-ebp +27259 c3/return +27260 +27261 translate-mu-clear-object-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +27262 # . prologue +27263 55/push-ebp +27264 89/<- %ebp 4/r32/esp +27265 # . save registers +27266 50/push-eax +27267 # +27268 (emit-indent *(ebp+8) *Curr-block-depth) +27269 (write-buffered *(ebp+8) "(zero-out") +27270 # eax = stmt +27271 8b/-> *(ebp+0xc) 0/r32/eax +27272 # var dest/eax: (addr stmt-var) = stmt->inouts[0] +27273 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27274 # +27275 (emit-subx-call-operand *(ebp+8) %eax) +27276 (write-buffered *(ebp+8) Space) +27277 (addr-payload-size %eax *(ebp+0x10) *(ebp+0x14)) # => eax +27278 (write-int32-hex-buffered *(ebp+8) %eax) +27279 (write-buffered *(ebp+8) ")\n") +27280 $translate-mu-clear-object-stmt:end: +27281 # . restore registers +27282 58/pop-to-eax +27283 # . epilogue +27284 89/<- %esp 5/r32/ebp +27285 5d/pop-to-ebp +27286 c3/return +27287 +27288 translate-mu-allocate-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +27289 # . prologue +27290 55/push-ebp +27291 89/<- %ebp 4/r32/esp +27292 # . save registers +27293 50/push-eax +27294 56/push-esi +27295 57/push-edi +27296 # esi = stmt +27297 8b/-> *(ebp+0xc) 6/r32/esi +27298 # var target/edi: (addr stmt-var) = stmt->inouts[0] +27299 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27300 89/<- %edi 0/r32/eax +27301 # +27302 (emit-indent *(ebp+8) *Curr-block-depth) +27303 (write-buffered *(ebp+8) "(allocate Heap ") +27304 (addr-handle-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +27305 (write-int32-hex-buffered *(ebp+8) %eax) +27306 (emit-subx-call-operand *(ebp+8) %edi) +27307 (write-buffered *(ebp+8) ")\n") +27308 $translate-mu-allocate-stmt:end: +27309 # . restore registers +27310 5f/pop-to-edi +27311 5e/pop-to-esi +27312 58/pop-to-eax +27313 # . epilogue +27314 89/<- %esp 5/r32/ebp +27315 5d/pop-to-ebp +27316 c3/return +27317 +27318 addr-handle-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +27319 # . prologue +27320 55/push-ebp +27321 89/<- %ebp 4/r32/esp +27322 # var t/eax: (addr type-tree) = s->value->type +27323 8b/-> *(ebp+8) 0/r32/eax +27324 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27325 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +27326 # TODO: check eax != 0 +27327 # TODO: check !t->is-atom? +27328 # TODO: check t->left == addr +27329 # t = t->right +27330 $addr-handle-payload-size:skip-addr: +27331 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +27332 # TODO: check eax != 0 +27333 # TODO: check !t->is-atom? +27334 # TODO: check t->left == handle +27335 # t = t->right +27336 $addr-handle-payload-size:skip-handle: +27337 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +27338 # TODO: check eax != 0 +27339 # if !t->is-atom? t = t->left +27340 81 7/subop/compare *eax 0/imm32/false +27341 { +27342 75/jump-if-!= break/disp8 +27343 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +27344 } +27345 # TODO: check t->is-atom? +27346 # return size(t->value) +27347 (size-of-type-id *(eax+4)) # Type-tree-value => eax +27348 $addr-handle-payload-size:end: +27349 # . epilogue +27350 89/<- %esp 5/r32/ebp +27351 5d/pop-to-ebp +27352 c3/return +27353 +27354 addr-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +27355 # . prologue +27356 55/push-ebp +27357 89/<- %ebp 4/r32/esp +27358 # var t/eax: (addr type-tree) = s->value->type +27359 8b/-> *(ebp+8) 0/r32/eax +27360 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27361 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +27362 # TODO: check eax != 0 +27363 # TODO: check !t->is-atom? +27364 # TODO: check t->left == addr +27365 # t = t->right +27366 $addr-payload-size:skip-addr: +27367 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +27368 # TODO: check eax != 0 +27369 # if !t->is-atom? t = t->left +27370 81 7/subop/compare *eax 0/imm32/false +27371 { +27372 75/jump-if-!= break/disp8 +27373 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +27374 } +27375 # TODO: check t->is-atom? +27376 # return size(t->value) +27377 (size-of-type-id *(eax+4)) # Type-tree-value => eax +27378 $addr-payload-size:end: +27379 # . epilogue +27380 89/<- %esp 5/r32/ebp +27381 5d/pop-to-ebp +27382 c3/return +27383 +27384 translate-mu-populate-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +27385 # . prologue +27386 55/push-ebp +27387 89/<- %ebp 4/r32/esp +27388 # . save registers +27389 50/push-eax +27390 51/push-ecx +27391 56/push-esi +27392 57/push-edi +27393 # esi = stmt +27394 8b/-> *(ebp+0xc) 6/r32/esi +27395 # var target/edi: (addr stmt-var) = stmt->inouts[0] +27396 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27397 89/<- %edi 0/r32/eax +27398 # var len/ecx: (addr stmt-var) = stmt->inouts[1] +27399 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +27400 89/<- %ecx 0/r32/eax +27401 # +27402 (emit-indent *(ebp+8) *Curr-block-depth) +27403 (write-buffered *(ebp+8) "(allocate-array2 Heap ") +27404 (addr-handle-array-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +27405 (write-int32-hex-buffered *(ebp+8) %eax) +27406 (emit-subx-call-operand *(ebp+8) %ecx) +27407 (emit-subx-call-operand *(ebp+8) %edi) +27408 (write-buffered *(ebp+8) ")\n") +27409 $translate-mu-populate-stmt:end: +27410 # . restore registers +27411 5f/pop-to-edi +27412 5e/pop-to-esi +27413 59/pop-to-ecx +27414 58/pop-to-eax +27415 # . epilogue +27416 89/<- %esp 5/r32/ebp +27417 5d/pop-to-ebp +27418 c3/return +27419 +27420 translate-mu-populate-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +27421 # . prologue +27422 55/push-ebp +27423 89/<- %ebp 4/r32/esp +27424 # . save registers +27425 50/push-eax +27426 51/push-ecx +27427 56/push-esi +27428 57/push-edi +27429 # esi = stmt +27430 8b/-> *(ebp+0xc) 6/r32/esi +27431 # var target/edi: (addr stmt-var) = stmt->inouts[0] +27432 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27433 89/<- %edi 0/r32/eax +27434 # var len/ecx: (addr stmt-var) = stmt->inouts[1] +27435 (lookup *(edi+8) *(edi+0xc)) # Stmt-var-next Stmt-var-next => eax +27436 89/<- %ecx 0/r32/eax +27437 # +27438 (emit-indent *(ebp+8) *Curr-block-depth) +27439 (write-buffered *(ebp+8) "(new-stream Heap ") +27440 (addr-handle-stream-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +27441 (write-int32-hex-buffered *(ebp+8) %eax) +27442 (emit-subx-call-operand *(ebp+8) %ecx) +27443 (emit-subx-call-operand *(ebp+8) %edi) +27444 (write-buffered *(ebp+8) ")\n") +27445 $translate-mu-populate-stream-stmt:end: +27446 # . restore registers +27447 5f/pop-to-edi +27448 5e/pop-to-esi +27449 59/pop-to-ecx +27450 58/pop-to-eax +27451 # . epilogue +27452 89/<- %esp 5/r32/ebp +27453 5d/pop-to-ebp +27454 c3/return +27455 +27456 translate-mu-read-from-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +27457 # . prologue +27458 55/push-ebp +27459 89/<- %ebp 4/r32/esp +27460 # . save registers +27461 50/push-eax +27462 51/push-ecx +27463 56/push-esi +27464 57/push-edi +27465 # esi = stmt +27466 8b/-> *(ebp+0xc) 6/r32/esi +27467 # var stream/ecx: (addr stmt-var) = stmt->inouts[0] +27468 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27469 89/<- %ecx 0/r32/eax +27470 # var target/edi: (addr stmt-var) = stmt->inouts[1] +27471 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +27472 89/<- %edi 0/r32/eax +27473 # +27474 (emit-indent *(ebp+8) *Curr-block-depth) +27475 (write-buffered *(ebp+8) "(read-from-stream") +27476 (emit-subx-call-operand *(ebp+8) %ecx) +27477 (emit-subx-call-operand *(ebp+8) %edi) +27478 (write-buffered *(ebp+8) Space) +27479 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +27480 (write-int32-hex-buffered *(ebp+8) %eax) +27481 (write-buffered *(ebp+8) ")\n") +27482 $translate-mu-read-from-stream-stmt:end: +27483 # . restore registers +27484 5f/pop-to-edi +27485 5e/pop-to-esi +27486 59/pop-to-ecx +27487 58/pop-to-eax +27488 # . epilogue +27489 89/<- %esp 5/r32/ebp +27490 5d/pop-to-ebp +27491 c3/return +27492 +27493 translate-mu-write-to-stream-stmt: # out: (addr buffered-file), stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +27494 # . prologue +27495 55/push-ebp +27496 89/<- %ebp 4/r32/esp +27497 # . save registers +27498 50/push-eax +27499 51/push-ecx +27500 56/push-esi +27501 57/push-edi +27502 # esi = stmt +27503 8b/-> *(ebp+0xc) 6/r32/esi +27504 # var stream/ecx: (addr stmt-var) = stmt->inouts[0] +27505 (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27506 89/<- %ecx 0/r32/eax +27507 # var target/edi: (addr stmt-var) = stmt->inouts[1] +27508 (lookup *(ecx+8) *(ecx+0xc)) # Stmt-var-next Stmt-var-next => eax +27509 89/<- %edi 0/r32/eax +27510 # +27511 (emit-indent *(ebp+8) *Curr-block-depth) +27512 (write-buffered *(ebp+8) "(write-to-stream") +27513 (emit-subx-call-operand *(ebp+8) %ecx) +27514 (flush *(ebp+8)) +27515 (emit-subx-call-operand *(ebp+8) %edi) +27516 (flush *(ebp+8)) +27517 (write-buffered *(ebp+8) Space) +27518 (flush *(ebp+8)) +27519 (addr-payload-size %edi *(ebp+0x10) *(ebp+0x14)) # => eax +27520 (write-int32-hex-buffered *(ebp+8) %eax) +27521 (write-buffered *(ebp+8) ")\n") +27522 $translate-mu-write-to-stream-stmt:end: +27523 # . restore registers +27524 5f/pop-to-edi +27525 5e/pop-to-esi +27526 59/pop-to-ecx +27527 58/pop-to-eax +27528 # . epilogue +27529 89/<- %esp 5/r32/ebp +27530 5d/pop-to-ebp +27531 c3/return +27532 +27533 addr-handle-array-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +27534 # . prologue +27535 55/push-ebp +27536 89/<- %ebp 4/r32/esp +27537 # var t/eax: (addr type-tree) = s->value->type +27538 8b/-> *(ebp+8) 0/r32/eax +27539 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27540 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +27541 # TODO: check eax != 0 +27542 # TODO: check !t->is-atom? +27543 # TODO: check t->left == addr +27544 # t = t->right +27545 $addr-handle-array-payload-size:skip-addr: +27546 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +27547 # TODO: check eax != 0 +27548 # TODO: check !t->is-atom? +27549 # TODO: check t->left == handle +27550 # t = t->right +27551 $addr-handle-array-payload-size:skip-handle: +27552 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +27553 # TODO: check eax != 0 +27554 # TODO: check !t->is-atom? +27555 # TODO: check t->left == array +27556 # t = t->right +27557 $addr-handle-array-payload-size:skip-array: +27558 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +27559 # TODO: check eax != 0 +27560 # if !t->is-atom? t = t->left +27561 81 7/subop/compare *eax 0/imm32/false +27562 { +27563 75/jump-if-!= break/disp8 +27564 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +27565 } +27566 $addr-handle-array-payload-size:compute-size: +27567 # TODO: check t->is-atom? +27568 # return size(t->value) +27569 (size-of-type-id-as-array-element *(eax+4)) # Type-tree-value => eax +27570 $addr-handle-array-payload-size:end: +27571 # . epilogue +27572 89/<- %esp 5/r32/ebp +27573 5d/pop-to-ebp +27574 c3/return +27575 +27576 addr-handle-stream-payload-size: # s: (addr stmt-var), err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: int +27577 # . prologue +27578 55/push-ebp +27579 89/<- %ebp 4/r32/esp +27580 # var t/eax: (addr type-tree) = s->value->type +27581 8b/-> *(ebp+8) 0/r32/eax +27582 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27583 (lookup *(eax+8) *(eax+0xc)) # Var-type Var-type => eax +27584 # TODO: check eax != 0 +27585 # TODO: check !t->is-atom? +27586 # TODO: check t->left == addr +27587 # t = t->right +27588 $addr-handle-stream-payload-size:skip-addr: +27589 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +27590 # TODO: check eax != 0 +27591 # TODO: check !t->is-atom? +27592 # TODO: check t->left == handle +27593 # t = t->right +27594 $addr-handle-stream-payload-size:skip-handle: +27595 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +27596 # TODO: check eax != 0 +27597 # TODO: check !t->is-atom? +27598 # TODO: check t->left == stream +27599 # t = t->right +27600 $addr-handle-stream-payload-size:skip-stream: +27601 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +27602 # TODO: check eax != 0 +27603 # if !t->is-atom? t = t->left +27604 81 7/subop/compare *eax 0/imm32/false +27605 { +27606 75/jump-if-!= break/disp8 +27607 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +27608 } +27609 $addr-handle-stream-payload-size:compute-size: +27610 # TODO: check t->is-atom? +27611 # return size(t->value) +27612 (size-of-type-id-as-array-element *(eax+4)) # Type-tree-value => eax +27613 $addr-handle-stream-payload-size:end: +27614 # . epilogue +27615 89/<- %esp 5/r32/ebp +27616 5d/pop-to-ebp +27617 c3/return +27618 +27619 power-of-2?: # n: int, err: (addr buffered-file), ed: (addr exit-descriptor) -> result/eax: boolean +27620 # precondition: n is positive +27621 # . prologue +27622 55/push-ebp +27623 89/<- %ebp 4/r32/esp +27624 # eax = n +27625 8b/-> *(ebp+8) 0/r32/eax +27626 # if (n < 0) abort +27627 3d/compare-eax-with 0/imm32 +27628 0f 8c/jump-if-< $power-of-2?:abort/disp32 +27629 # var tmp/eax: int = n-1 +27630 48/decrement-eax +27631 # var tmp2/eax: int = n & tmp +27632 23/and-> *(ebp+8) 0/r32/eax +27633 # return (tmp2 == 0) +27634 3d/compare-eax-and 0/imm32 +27635 0f 94/set-byte-if-= %al +27636 81 4/subop/and %eax 0xff/imm32 +27637 $power-of-2?:end: +27638 # . epilogue +27639 89/<- %esp 5/r32/ebp +27640 5d/pop-to-ebp +27641 c3/return +27642 +27643 $power-of-2?:abort: +27644 (write-buffered *(ebp+0xc) "power-of-2?: negative number\n") +27645 (flush *(ebp+0xc)) +27646 (stop *(ebp+0x10) 1) +27647 # never gets here +27648 +27649 num-shift-rights: # n: int -> result/eax: int +27650 # precondition: n is a positive power of 2 +27651 # . prologue +27652 55/push-ebp +27653 89/<- %ebp 4/r32/esp +27654 # . save registers +27655 51/push-ecx +27656 # var curr/ecx: int = n +27657 8b/-> *(ebp+8) 1/r32/ecx +27658 # result = 0 +27659 b8/copy-to-eax 0/imm32 +27660 { +27661 # if (curr <= 1) break +27662 81 7/subop/compare %ecx 1/imm32 +27663 7e/jump-if-<= break/disp8 +27664 40/increment-eax +27665 c1/shift 5/subop/arithmetic-right %ecx 1/imm8 +27666 eb/jump loop/disp8 +27667 } +27668 $num-shift-rights:end: +27669 # . restore registers +27670 59/pop-to-ecx +27671 # . epilogue +27672 89/<- %esp 5/r32/ebp +27673 5d/pop-to-ebp +27674 c3/return +27675 +27676 mu-get-offset: # stmt: (addr stmt) -> result/eax: int +27677 # . prologue +27678 55/push-ebp +27679 89/<- %ebp 4/r32/esp +27680 # var second-inout/eax: (addr stmt-var) = stmt->inouts->next +27681 8b/-> *(ebp+8) 0/r32/eax +27682 (lookup *(eax+0xc) *(eax+0x10)) # Stmt1-inouts Stmt1-inouts => eax +27683 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +27684 # var output-var/eax: (addr var) = second-inout->value +27685 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +27686 #? (write-buffered Stderr "mu-get-offset: ") +27687 #? (write-int32-hex-buffered Stderr %eax) +27688 #? (write-buffered Stderr " name: ") +27689 #? 50/push-eax +27690 #? (lookup *eax *(eax+4)) # Var-name +27691 #? (write-buffered Stderr %eax) +27692 #? 58/pop-to-eax +27693 #? (write-buffered Stderr Newline) +27694 #? (flush Stderr) +27695 # return output-var->stack-offset +27696 8b/-> *(eax+0x14) 0/r32/eax # Var-offset +27697 #? (write-buffered Stderr "=> ") +27698 #? (write-int32-hex-buffered Stderr %eax) +27699 #? (write-buffered Stderr Newline) +27700 #? (flush Stderr) +27701 $emit-get-offset:end: +27702 # . epilogue +27703 89/<- %esp 5/r32/ebp +27704 5d/pop-to-ebp +27705 c3/return +27706 +27707 emit-subx-block: # out: (addr buffered-file), block: (addr block), vars: (addr stack live-var), fn: (addr function), err: (addr buffered-file), ed: (addr exit-descriptor) +27708 # . prologue +27709 55/push-ebp +27710 89/<- %ebp 4/r32/esp +27711 # . save registers +27712 50/push-eax +27713 51/push-ecx +27714 56/push-esi +27715 # esi = block +27716 8b/-> *(ebp+0xc) 6/r32/esi +27717 # block->var->block-depth = *Curr-block-depth +27718 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax +27719 8b/-> *Curr-block-depth 1/r32/ecx +27720 89/<- *(eax+0x10) 1/r32/ecx # Var-block-depth +27721 # var stmts/eax: (addr list stmt) = lookup(block->statements) +27722 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax +27723 # +27724 { +27725 $emit-subx-block:check-empty: +27726 3d/compare-eax-and 0/imm32 +27727 0f 84/jump-if-= break/disp32 +27728 (emit-indent *(ebp+8) *Curr-block-depth) +27729 (write-buffered *(ebp+8) "{\n") +27730 # var v/ecx: (addr var) = lookup(block->var) +27731 (lookup *(esi+0xc) *(esi+0x10)) # Block-var Block-var => eax +27732 89/<- %ecx 0/r32/eax +27733 # +27734 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +27735 (write-buffered *(ebp+8) %eax) +27736 (write-buffered *(ebp+8) ":loop:\n") +27737 ff 0/subop/increment *Curr-block-depth +27738 (push *(ebp+0x10) *(esi+0xc)) # Block-var +27739 (push *(ebp+0x10) *(esi+0x10)) # Block-var +27740 (push *(ebp+0x10) 0) # false +27741 # emit block->statements +27742 (lookup *(esi+4) *(esi+8)) # Block-stmts Block-stmts => eax +27743 (emit-subx-stmt-list *(ebp+8) %eax *(ebp+0x10) *(ebp+0x14) *(ebp+0x18) *(ebp+0x1c)) +27744 (pop *(ebp+0x10)) # => eax +27745 (pop *(ebp+0x10)) # => eax +27746 (pop *(ebp+0x10)) # => eax +27747 ff 1/subop/decrement *Curr-block-depth +27748 (emit-indent *(ebp+8) *Curr-block-depth) +27749 (write-buffered *(ebp+8) "}\n") +27750 (lookup *ecx *(ecx+4)) # Var-name Var-name => eax +27751 (write-buffered *(ebp+8) %eax) +27752 (write-buffered *(ebp+8) ":break:\n") +27753 } +27754 $emit-subx-block:end: +27755 # . restore registers +27756 5e/pop-to-esi +27757 59/pop-to-ecx +27758 58/pop-to-eax +27759 # . epilogue +27760 89/<- %esp 5/r32/ebp +27761 5d/pop-to-ebp +27762 c3/return +27763 +27764 # Primitives supported +27765 # See mu_instructions for a summary of this linked-list data structure. +27766 # +27767 # For each operation, put variants with hard-coded registers before flexible ones. +27768 # +27769 # Unfortunately, our restrictions on addresses require that various fields in +27770 # primitives be handles, which complicates these definitions. +27771 # - we need to insert dummy fields all over the place for fake alloc-ids +27772 # - we can't use our syntax sugar of quoted literals for string fields +27773 # +27774 # Fake alloc-ids are needed because our type definitions up top require +27775 # handles but it's clearer to statically allocate these long-lived objects. +27776 # Fake alloc-ids are perfectly safe, but they can't be reclaimed. +27777 # +27778 # Every 'object' below starts with a fake alloc-id. It may also contain other +27779 # fake alloc-ids for various handle fields. +27780 # +27781 # I think of objects starting with a fake alloc-id as having type 'payload'. +27782 # It's not really intended to be created dynamically; for that use `allocate` +27783 # as usual. +27784 # +27785 # Idea for a notation to simplify such definitions: +27786 # _Primitive-increment-eax: # (payload primitive) +27787 # 0x11/alloc-id:fake:payload +27788 # 0x11 @(0x11 "increment") # name +27789 # 0 0 # inouts +27790 # 0x11 @(0x11/payload +27791 # 0x11 @(0x11/payload # List-value +27792 # 0 0 # Var-name +27793 # 0x11 @(0x11 # Var-type +27794 # 1/is-atom +27795 # 1/value 0/unused # Type-tree-left +27796 # 0 0 # Type-tree-right +27797 # ) +27798 # 1 # block-depth +27799 # 0 # stack-offset +27800 # 0x11 @(0x11 "eax") # Var-register +27801 # ) +27802 # 0 0) # List-next +27803 # ... +27804 # _Primitive-increment-ecx/imm32/next +27805 # ... +27806 # Awfully complex and non-obvious. But also clearly signals there's something +27807 # to learn here, so may be worth trying. +27808 # +27809 # '@' is just an initial thought. Punctuation used so far in Mu: () * % # / " +27810 # +27811 # For now we'll continue to just use comments and manually ensure they stay up +27812 # to date. +27813 == data +27814 Primitives: # (addr primitive) +27815 # - increment/decrement +27816 _Primitive-increment-eax: # (addr primitive) +27817 # var/eax <- increment => 40/increment-eax +27818 0x11/imm32/alloc-id:fake +27819 _string-increment/imm32/name +27820 0/imm32/no-inouts +27821 0/imm32/no-inouts +27822 0x11/imm32/alloc-id:fake +27823 Single-int-var-in-eax/imm32/outputs +27824 0x11/imm32/alloc-id:fake +27825 _string_40_increment_eax/imm32/subx-name +27826 0/imm32/no-rm32 +27827 0/imm32/no-r32 +27828 0/imm32/no-imm32 +27829 0/imm32/no-imm8 +27830 0/imm32/no-disp32 +27831 0/imm32/no-xm32 +27832 0/imm32/no-x32 +27833 0x11/imm32/alloc-id:fake +27834 _Primitive-increment-ecx/imm32/next +27835 _Primitive-increment-ecx: # (payload primitive) +27836 0x11/imm32/alloc-id:fake:payload +27837 # var/ecx <- increment => 41/increment-ecx +27838 0x11/imm32/alloc-id:fake +27839 _string-increment/imm32/name +27840 0/imm32/no-inouts +27841 0/imm32/no-inouts +27842 0x11/imm32/alloc-id:fake +27843 Single-int-var-in-ecx/imm32/outputs +27844 0x11/imm32/alloc-id:fake +27845 _string_41_increment_ecx/imm32/subx-name +27846 0/imm32/no-rm32 +27847 0/imm32/no-r32 +27848 0/imm32/no-imm32 +27849 0/imm32/no-imm8 +27850 0/imm32/no-disp32 +27851 0/imm32/no-xm32 +27852 0/imm32/no-x32 +27853 0x11/imm32/alloc-id:fake +27854 _Primitive-increment-edx/imm32/next +27855 _Primitive-increment-edx: # (payload primitive) +27856 0x11/imm32/alloc-id:fake:payload +27857 # var/edx <- increment => 42/increment-edx +27858 0x11/imm32/alloc-id:fake +27859 _string-increment/imm32/name +27860 0/imm32/no-inouts +27861 0/imm32/no-inouts +27862 0x11/imm32/alloc-id:fake +27863 Single-int-var-in-edx/imm32/outputs +27864 0x11/imm32/alloc-id:fake +27865 _string_42_increment_edx/imm32/subx-name +27866 0/imm32/no-rm32 +27867 0/imm32/no-r32 +27868 0/imm32/no-imm32 +27869 0/imm32/no-imm8 +27870 0/imm32/no-disp32 +27871 0/imm32/no-xm32 +27872 0/imm32/no-x32 +27873 0x11/imm32/alloc-id:fake +27874 _Primitive-increment-ebx/imm32/next +27875 _Primitive-increment-ebx: # (payload primitive) +27876 0x11/imm32/alloc-id:fake:payload +27877 # var/ebx <- increment => 43/increment-ebx +27878 0x11/imm32/alloc-id:fake +27879 _string-increment/imm32/name +27880 0/imm32/no-inouts +27881 0/imm32/no-inouts +27882 0x11/imm32/alloc-id:fake +27883 Single-int-var-in-ebx/imm32/outputs +27884 0x11/imm32/alloc-id:fake +27885 _string_43_increment_ebx/imm32/subx-name +27886 0/imm32/no-rm32 +27887 0/imm32/no-r32 +27888 0/imm32/no-imm32 +27889 0/imm32/no-imm8 +27890 0/imm32/no-disp32 +27891 0/imm32/no-xm32 +27892 0/imm32/no-x32 +27893 0x11/imm32/alloc-id:fake +27894 _Primitive-increment-esi/imm32/next +27895 _Primitive-increment-esi: # (payload primitive) +27896 0x11/imm32/alloc-id:fake:payload +27897 # var/esi <- increment => 46/increment-esi +27898 0x11/imm32/alloc-id:fake +27899 _string-increment/imm32/name +27900 0/imm32/no-inouts +27901 0/imm32/no-inouts +27902 0x11/imm32/alloc-id:fake +27903 Single-int-var-in-esi/imm32/outputs +27904 0x11/imm32/alloc-id:fake +27905 _string_46_increment_esi/imm32/subx-name +27906 0/imm32/no-rm32 +27907 0/imm32/no-r32 +27908 0/imm32/no-imm32 +27909 0/imm32/no-imm8 +27910 0/imm32/no-disp32 +27911 0/imm32/no-xm32 +27912 0/imm32/no-x32 +27913 0x11/imm32/alloc-id:fake +27914 _Primitive-increment-edi/imm32/next +27915 _Primitive-increment-edi: # (payload primitive) +27916 0x11/imm32/alloc-id:fake:payload +27917 # var/edi <- increment => 47/increment-edi +27918 0x11/imm32/alloc-id:fake +27919 _string-increment/imm32/name +27920 0/imm32/no-inouts +27921 0/imm32/no-inouts +27922 0x11/imm32/alloc-id:fake +27923 Single-int-var-in-edi/imm32/outputs +27924 0x11/imm32/alloc-id:fake +27925 _string_47_increment_edi/imm32/subx-name +27926 0/imm32/no-rm32 +27927 0/imm32/no-r32 +27928 0/imm32/no-imm32 +27929 0/imm32/no-imm8 +27930 0/imm32/no-disp32 +27931 0/imm32/no-xm32 +27932 0/imm32/no-x32 +27933 0x11/imm32/alloc-id:fake +27934 _Primitive-decrement-eax/imm32/next +27935 _Primitive-decrement-eax: # (payload primitive) +27936 0x11/imm32/alloc-id:fake:payload +27937 # var/eax <- decrement => 48/decrement-eax +27938 0x11/imm32/alloc-id:fake +27939 _string-decrement/imm32/name +27940 0/imm32/no-inouts +27941 0/imm32/no-inouts +27942 0x11/imm32/alloc-id:fake +27943 Single-int-var-in-eax/imm32/outputs +27944 0x11/imm32/alloc-id:fake +27945 _string_48_decrement_eax/imm32/subx-name +27946 0/imm32/no-rm32 +27947 0/imm32/no-r32 +27948 0/imm32/no-imm32 +27949 0/imm32/no-imm8 +27950 0/imm32/no-disp32 +27951 0/imm32/no-xm32 +27952 0/imm32/no-x32 +27953 0x11/imm32/alloc-id:fake +27954 _Primitive-decrement-ecx/imm32/next +27955 _Primitive-decrement-ecx: # (payload primitive) +27956 0x11/imm32/alloc-id:fake:payload +27957 # var/ecx <- decrement => 49/decrement-ecx +27958 0x11/imm32/alloc-id:fake +27959 _string-decrement/imm32/name +27960 0/imm32/no-inouts +27961 0/imm32/no-inouts +27962 0x11/imm32/alloc-id:fake +27963 Single-int-var-in-ecx/imm32/outputs +27964 0x11/imm32/alloc-id:fake +27965 _string_49_decrement_ecx/imm32/subx-name +27966 0/imm32/no-rm32 +27967 0/imm32/no-r32 +27968 0/imm32/no-imm32 +27969 0/imm32/no-imm8 +27970 0/imm32/no-disp32 +27971 0/imm32/no-xm32 +27972 0/imm32/no-x32 +27973 0x11/imm32/alloc-id:fake +27974 _Primitive-decrement-edx/imm32/next +27975 _Primitive-decrement-edx: # (payload primitive) +27976 0x11/imm32/alloc-id:fake:payload +27977 # var/edx <- decrement => 4a/decrement-edx +27978 0x11/imm32/alloc-id:fake +27979 _string-decrement/imm32/name +27980 0/imm32/no-inouts +27981 0/imm32/no-inouts +27982 0x11/imm32/alloc-id:fake +27983 Single-int-var-in-edx/imm32/outputs +27984 0x11/imm32/alloc-id:fake +27985 _string_4a_decrement_edx/imm32/subx-name +27986 0/imm32/no-rm32 +27987 0/imm32/no-r32 +27988 0/imm32/no-imm32 +27989 0/imm32/no-imm8 +27990 0/imm32/no-disp32 +27991 0/imm32/no-xm32 +27992 0/imm32/no-x32 +27993 0x11/imm32/alloc-id:fake +27994 _Primitive-decrement-ebx/imm32/next +27995 _Primitive-decrement-ebx: # (payload primitive) +27996 0x11/imm32/alloc-id:fake:payload +27997 # var/ebx <- decrement => 4b/decrement-ebx +27998 0x11/imm32/alloc-id:fake +27999 _string-decrement/imm32/name +28000 0/imm32/no-inouts +28001 0/imm32/no-inouts +28002 0x11/imm32/alloc-id:fake +28003 Single-int-var-in-ebx/imm32/outputs +28004 0x11/imm32/alloc-id:fake +28005 _string_4b_decrement_ebx/imm32/subx-name +28006 0/imm32/no-rm32 +28007 0/imm32/no-r32 +28008 0/imm32/no-imm32 +28009 0/imm32/no-imm8 +28010 0/imm32/no-disp32 +28011 0/imm32/no-xm32 +28012 0/imm32/no-x32 +28013 0x11/imm32/alloc-id:fake +28014 _Primitive-decrement-esi/imm32/next +28015 _Primitive-decrement-esi: # (payload primitive) +28016 0x11/imm32/alloc-id:fake:payload +28017 # var/esi <- decrement => 4e/decrement-esi +28018 0x11/imm32/alloc-id:fake +28019 _string-decrement/imm32/name +28020 0/imm32/no-inouts +28021 0/imm32/no-inouts +28022 0x11/imm32/alloc-id:fake +28023 Single-int-var-in-esi/imm32/outputs +28024 0x11/imm32/alloc-id:fake +28025 _string_4e_decrement_esi/imm32/subx-name +28026 0/imm32/no-rm32 +28027 0/imm32/no-r32 +28028 0/imm32/no-imm32 +28029 0/imm32/no-imm8 +28030 0/imm32/no-disp32 +28031 0/imm32/no-xm32 +28032 0/imm32/no-x32 +28033 0x11/imm32/alloc-id:fake +28034 _Primitive-decrement-edi/imm32/next +28035 _Primitive-decrement-edi: # (payload primitive) +28036 0x11/imm32/alloc-id:fake:payload +28037 # var/edi <- decrement => 4f/decrement-edi +28038 0x11/imm32/alloc-id:fake +28039 _string-decrement/imm32/name +28040 0/imm32/no-inouts +28041 0/imm32/no-inouts +28042 0x11/imm32/alloc-id:fake +28043 Single-int-var-in-edi/imm32/outputs +28044 0x11/imm32/alloc-id:fake +28045 _string_4f_decrement_edi/imm32/subx-name +28046 0/imm32/no-rm32 +28047 0/imm32/no-r32 +28048 0/imm32/no-imm32 +28049 0/imm32/no-imm8 +28050 0/imm32/no-disp32 +28051 0/imm32/no-xm32 +28052 0/imm32/no-x32 +28053 0x11/imm32/alloc-id:fake +28054 _Primitive-increment-mem/imm32/next +28055 _Primitive-increment-mem: # (payload primitive) +28056 0x11/imm32/alloc-id:fake:payload +28057 # increment var => ff 0/subop/increment *(ebp+__) 28058 0x11/imm32/alloc-id:fake -28059 Single-byte-var-in-some-register/imm32/inouts +28059 _string-increment/imm32/name 28060 0x11/imm32/alloc-id:fake -28061 Single-byte-var-in-some-register/imm32/outputs -28062 0x11/imm32/alloc-id:fake -28063 _string_8a_copy_byte/imm32/subx-name -28064 1/imm32/rm32-is-first-inout -28065 3/imm32/r32-is-first-output -28066 0/imm32/no-imm32 -28067 0/imm32/no-imm8 -28068 0/imm32/no-disp32 -28069 0/imm32/no-xm32 -28070 0/imm32/no-x32 -28071 0x11/imm32/alloc-id:fake -28072 _Primitive-copy-byte-from-mem/imm32/next -28073 _Primitive-copy-byte-from-mem: -28074 0x11/imm32/alloc-id:fake:payload -28075 # var/reg <- copy-byte *var2/reg2 => 8a/byte-> *var2 var/r32 -28076 0x11/imm32/alloc-id:fake -28077 _string-copy-byte/imm32/name +28061 Single-int-var-in-mem/imm32/inouts +28062 0/imm32/no-outputs +28063 0/imm32/no-outputs +28064 0x11/imm32/alloc-id:fake +28065 _string_ff_subop_increment/imm32/subx-name +28066 1/imm32/rm32-is-first-inout +28067 0/imm32/no-r32 +28068 0/imm32/no-imm32 +28069 0/imm32/no-imm8 +28070 0/imm32/no-disp32 +28071 0/imm32/no-xm32 +28072 0/imm32/no-x32 +28073 0x11/imm32/alloc-id:fake +28074 _Primitive-increment-reg/imm32/next +28075 _Primitive-increment-reg: # (payload primitive) +28076 0x11/imm32/alloc-id:fake:payload +28077 # var/reg <- increment => ff 0/subop/increment %__ 28078 0x11/imm32/alloc-id:fake -28079 Single-byte-var-in-mem/imm32/inouts -28080 0x11/imm32/alloc-id:fake -28081 Single-byte-var-in-some-register/imm32/outputs +28079 _string-increment/imm32/name +28080 0/imm32/no-inouts +28081 0/imm32/no-inouts 28082 0x11/imm32/alloc-id:fake -28083 _string_8a_copy_byte/imm32/subx-name -28084 1/imm32/rm32-is-first-inout -28085 3/imm32/r32-is-first-output -28086 0/imm32/no-imm32 -28087 0/imm32/no-imm8 -28088 0/imm32/no-disp32 -28089 0/imm32/no-xm32 -28090 0/imm32/no-x32 -28091 0x11/imm32/alloc-id:fake -28092 _Primitive-copy-byte-to-mem/imm32/next -28093 _Primitive-copy-byte-to-mem: -28094 0x11/imm32/alloc-id:fake:payload -28095 # copy-byte-to *var1/reg1, var2/reg2 => 88/byte<- *reg1 reg2/r32 -28096 0x11/imm32/alloc-id:fake -28097 _string-copy-byte-to/imm32/name +28083 Single-int-var-in-some-register/imm32/outputs +28084 0x11/imm32/alloc-id:fake +28085 _string_ff_subop_increment/imm32/subx-name +28086 3/imm32/rm32-is-first-output +28087 0/imm32/no-r32 +28088 0/imm32/no-imm32 +28089 0/imm32/no-imm8 +28090 0/imm32/no-disp32 +28091 0/imm32/no-xm32 +28092 0/imm32/no-x32 +28093 0x11/imm32/alloc-id:fake +28094 _Primitive-decrement-mem/imm32/next +28095 _Primitive-decrement-mem: # (payload primitive) +28096 0x11/imm32/alloc-id:fake:payload +28097 # decrement var => ff 1/subop/decrement *(ebp+__) 28098 0x11/imm32/alloc-id:fake -28099 Two-args-byte-stack-byte-reg/imm32/inouts -28100 0/imm32/no-outputs -28101 0/imm32/no-outputs -28102 0x11/imm32/alloc-id:fake -28103 _string_88_copy_byte/imm32/subx-name -28104 1/imm32/rm32-is-first-inout -28105 2/imm32/r32-is-second-inout -28106 0/imm32/no-imm32 -28107 0/imm32/no-imm8 -28108 0/imm32/no-disp32 -28109 0/imm32/no-xm32 -28110 0/imm32/no-x32 -28111 0x11/imm32/alloc-id:fake -28112 _Primitive-address/imm32/next -28113 # - address -28114 _Primitive-address: # (payload primitive) -28115 0x11/imm32/alloc-id:fake:payload -28116 # var1/reg <- address var2 => 8d/copy-address var2/rm32 var1/r32 -28117 0x11/imm32/alloc-id:fake -28118 _string-address/imm32/name -28119 0x11/imm32/alloc-id:fake -28120 Single-int-var-in-mem/imm32/inouts -28121 0x11/imm32/alloc-id:fake -28122 Single-addr-var-in-some-register/imm32/outputs -28123 0x11/imm32/alloc-id:fake -28124 _string_8d_copy_address/imm32/subx-name -28125 1/imm32/rm32-is-first-inout -28126 3/imm32/r32-is-first-output -28127 0/imm32/no-imm32 -28128 0/imm32/no-imm8 -28129 0/imm32/no-disp32 -28130 0/imm32/no-xm32 -28131 0/imm32/no-x32 -28132 0x11/imm32/alloc-id:fake -28133 _Primitive-compare-reg-with-reg/imm32/next -28134 # - compare -28135 _Primitive-compare-reg-with-reg: # (payload primitive) -28136 0x11/imm32/alloc-id:fake:payload -28137 # compare var1/reg1 var2/reg2 => 39/compare var1/rm32 var2/r32 -28138 0x11/imm32/alloc-id:fake -28139 _string-compare/imm32/name -28140 0x11/imm32/alloc-id:fake -28141 Two-int-args-in-regs/imm32/inouts -28142 0/imm32/no-outputs -28143 0/imm32/no-outputs -28144 0x11/imm32/alloc-id:fake -28145 _string_39_compare->/imm32/subx-name -28146 1/imm32/rm32-is-first-inout -28147 2/imm32/r32-is-second-inout -28148 0/imm32/no-imm32 -28149 0/imm32/no-imm8 -28150 0/imm32/no-disp32 -28151 0/imm32/no-xm32 -28152 0/imm32/no-x32 -28153 0x11/imm32/alloc-id:fake -28154 _Primitive-compare-mem-with-reg/imm32/next -28155 _Primitive-compare-mem-with-reg: # (payload primitive) -28156 0x11/imm32/alloc-id:fake:payload -28157 # compare var1 var2/reg => 39/compare var1/rm32 var2/r32 -28158 0x11/imm32/alloc-id:fake -28159 _string-compare/imm32/name -28160 0x11/imm32/alloc-id:fake -28161 Two-args-int-stack-int-reg/imm32/inouts -28162 0/imm32/no-outputs -28163 0/imm32/no-outputs -28164 0x11/imm32/alloc-id:fake -28165 _string_39_compare->/imm32/subx-name -28166 1/imm32/rm32-is-first-inout -28167 2/imm32/r32-is-second-inout -28168 0/imm32/no-imm32 -28169 0/imm32/no-imm8 -28170 0/imm32/no-disp32 -28171 0/imm32/no-xm32 -28172 0/imm32/no-x32 -28173 0x11/imm32/alloc-id:fake -28174 _Primitive-compare-reg-with-mem/imm32/next -28175 _Primitive-compare-reg-with-mem: # (payload primitive) -28176 0x11/imm32/alloc-id:fake:payload -28177 # compare var1/reg var2 => 3b/compare<- var2/rm32 var1/r32 -28178 0x11/imm32/alloc-id:fake -28179 _string-compare/imm32/name -28180 0x11/imm32/alloc-id:fake -28181 Two-args-int-reg-int-stack/imm32/inouts -28182 0/imm32/no-outputs +28099 _string-decrement/imm32/name +28100 0x11/imm32/alloc-id:fake +28101 Single-int-var-in-mem/imm32/inouts +28102 0/imm32/no-outputs +28103 0/imm32/no-outputs +28104 0x11/imm32/alloc-id:fake +28105 _string_ff_subop_decrement/imm32/subx-name +28106 1/imm32/rm32-is-first-inout +28107 0/imm32/no-r32 +28108 0/imm32/no-imm32 +28109 0/imm32/no-imm8 +28110 0/imm32/no-disp32 +28111 0/imm32/no-xm32 +28112 0/imm32/no-x32 +28113 0x11/imm32/alloc-id:fake +28114 _Primitive-decrement-reg/imm32/next +28115 _Primitive-decrement-reg: # (payload primitive) +28116 0x11/imm32/alloc-id:fake:payload +28117 # var/reg <- decrement => ff 1/subop/decrement %__ +28118 0x11/imm32/alloc-id:fake +28119 _string-decrement/imm32/name +28120 0/imm32/no-inouts +28121 0/imm32/no-inouts +28122 0x11/imm32/alloc-id:fake +28123 Single-int-var-in-some-register/imm32/outputs +28124 0x11/imm32/alloc-id:fake +28125 _string_ff_subop_decrement/imm32/subx-name +28126 3/imm32/rm32-is-first-output +28127 0/imm32/no-r32 +28128 0/imm32/no-imm32 +28129 0/imm32/no-imm8 +28130 0/imm32/no-disp32 +28131 0/imm32/no-xm32 +28132 0/imm32/no-x32 +28133 0x11/imm32/alloc-id:fake +28134 _Primitive-add-to-eax/imm32/next +28135 # - add +28136 _Primitive-add-to-eax: # (payload primitive) +28137 0x11/imm32/alloc-id:fake:payload +28138 # var/eax <- add lit => 05/add-to-eax lit/imm32 +28139 0x11/imm32/alloc-id:fake +28140 _string-add/imm32/name +28141 0x11/imm32/alloc-id:fake +28142 Single-lit-var/imm32/inouts +28143 0x11/imm32/alloc-id:fake +28144 Single-int-var-in-eax/imm32/outputs +28145 0x11/imm32/alloc-id:fake +28146 _string_05_add_to_eax/imm32/subx-name +28147 0/imm32/no-rm32 +28148 0/imm32/no-r32 +28149 1/imm32/imm32-is-first-inout +28150 0/imm32/no-imm8 +28151 0/imm32/no-disp32 +28152 0/imm32/no-xm32 +28153 0/imm32/no-x32 +28154 0x11/imm32/alloc-id:fake +28155 _Primitive-add-reg-to-reg/imm32/next +28156 _Primitive-add-reg-to-reg: # (payload primitive) +28157 0x11/imm32/alloc-id:fake:payload +28158 # var1/reg <- add var2/reg => 01/add-to var1/rm32 var2/r32 +28159 0x11/imm32/alloc-id:fake +28160 _string-add/imm32/name +28161 0x11/imm32/alloc-id:fake +28162 Single-int-var-in-some-register/imm32/inouts +28163 0x11/imm32/alloc-id:fake +28164 Single-int-var-in-some-register/imm32/outputs +28165 0x11/imm32/alloc-id:fake +28166 _string_01_add_to/imm32/subx-name +28167 3/imm32/rm32-is-first-output +28168 1/imm32/r32-is-first-inout +28169 0/imm32/no-imm32 +28170 0/imm32/no-imm8 +28171 0/imm32/no-disp32 +28172 0/imm32/no-xm32 +28173 0/imm32/no-x32 +28174 0x11/imm32/alloc-id:fake +28175 _Primitive-add-reg-to-mem/imm32/next +28176 _Primitive-add-reg-to-mem: # (payload primitive) +28177 0x11/imm32/alloc-id:fake:payload +28178 # add-to var1 var2/reg => 01/add-to var1 var2/r32 +28179 0x11/imm32/alloc-id:fake +28180 _string-add-to/imm32/name +28181 0x11/imm32/alloc-id:fake +28182 Two-args-int-stack-int-reg/imm32/inouts 28183 0/imm32/no-outputs -28184 0x11/imm32/alloc-id:fake -28185 _string_3b_compare<-/imm32/subx-name -28186 2/imm32/rm32-is-second-inout -28187 1/imm32/r32-is-first-inout -28188 0/imm32/no-imm32 -28189 0/imm32/no-imm8 -28190 0/imm32/no-disp32 -28191 0/imm32/no-xm32 -28192 0/imm32/no-x32 -28193 0x11/imm32/alloc-id:fake -28194 _Primitive-compare-eax-with-literal/imm32/next -28195 _Primitive-compare-eax-with-literal: # (payload primitive) -28196 0x11/imm32/alloc-id:fake:payload -28197 # compare var1/eax n => 3d/compare-eax-with n/imm32 -28198 0x11/imm32/alloc-id:fake -28199 _string-compare/imm32/name -28200 0x11/imm32/alloc-id:fake -28201 Two-args-int-eax-int-literal/imm32/inouts -28202 0/imm32/no-outputs -28203 0/imm32/no-outputs -28204 0x11/imm32/alloc-id:fake -28205 _string_3d_compare_eax_with/imm32/subx-name -28206 0/imm32/no-rm32 -28207 0/imm32/no-r32 -28208 2/imm32/imm32-is-second-inout -28209 0/imm32/no-imm8 -28210 0/imm32/no-disp32 -28211 0/imm32/no-xm32 -28212 0/imm32/no-x32 -28213 0x11/imm32/alloc-id:fake -28214 _Primitive-compare-reg-with-literal/imm32/next -28215 _Primitive-compare-reg-with-literal: # (payload primitive) -28216 0x11/imm32/alloc-id:fake:payload -28217 # compare var1/reg n => 81 7/subop/compare %reg n/imm32 -28218 0x11/imm32/alloc-id:fake -28219 _string-compare/imm32/name -28220 0x11/imm32/alloc-id:fake -28221 Int-var-in-register-and-literal/imm32/inouts -28222 0/imm32/no-outputs -28223 0/imm32/no-outputs -28224 0x11/imm32/alloc-id:fake -28225 _string_81_subop_compare/imm32/subx-name -28226 1/imm32/rm32-is-first-inout -28227 0/imm32/no-r32 -28228 2/imm32/imm32-is-second-inout -28229 0/imm32/no-imm8 -28230 0/imm32/no-disp32 -28231 0/imm32/no-xm32 -28232 0/imm32/no-x32 -28233 0x11/imm32/alloc-id:fake -28234 _Primitive-compare-mem-with-literal/imm32/next -28235 _Primitive-compare-mem-with-literal: # (payload primitive) -28236 0x11/imm32/alloc-id:fake:payload -28237 # compare var1 n => 81 7/subop/compare *(ebp+___) n/imm32 -28238 0x11/imm32/alloc-id:fake -28239 _string-compare/imm32/name -28240 0x11/imm32/alloc-id:fake -28241 Int-var-and-literal/imm32/inouts -28242 0/imm32/no-outputs +28184 0/imm32/no-outputs +28185 0x11/imm32/alloc-id:fake +28186 _string_01_add_to/imm32/subx-name +28187 1/imm32/rm32-is-first-inout +28188 2/imm32/r32-is-second-inout +28189 0/imm32/no-imm32 +28190 0/imm32/no-imm8 +28191 0/imm32/no-disp32 +28192 0/imm32/no-xm32 +28193 0/imm32/no-x32 +28194 0x11/imm32/alloc-id:fake +28195 _Primitive-add-mem-to-reg/imm32/next +28196 _Primitive-add-mem-to-reg: # (payload primitive) +28197 0x11/imm32/alloc-id:fake:payload +28198 # var1/reg <- add var2 => 03/add var2/rm32 var1/r32 +28199 0x11/imm32/alloc-id:fake +28200 _string-add/imm32/name +28201 0x11/imm32/alloc-id:fake +28202 Single-int-var-in-mem/imm32/inouts +28203 0x11/imm32/alloc-id:fake +28204 Single-int-var-in-some-register/imm32/outputs +28205 0x11/imm32/alloc-id:fake +28206 _string_03_add/imm32/subx-name +28207 1/imm32/rm32-is-first-inout +28208 3/imm32/r32-is-first-output +28209 0/imm32/no-imm32 +28210 0/imm32/no-imm8 +28211 0/imm32/no-disp32 +28212 0/imm32/no-xm32 +28213 0/imm32/no-x32 +28214 0x11/imm32/alloc-id:fake +28215 _Primitive-add-lit-to-reg/imm32/next +28216 _Primitive-add-lit-to-reg: # (payload primitive) +28217 0x11/imm32/alloc-id:fake:payload +28218 # var1/reg <- add lit => 81 0/subop/add var1/rm32 lit/imm32 +28219 0x11/imm32/alloc-id:fake +28220 _string-add/imm32/name +28221 0x11/imm32/alloc-id:fake +28222 Single-lit-var/imm32/inouts +28223 0x11/imm32/alloc-id:fake +28224 Single-int-var-in-some-register/imm32/outputs +28225 0x11/imm32/alloc-id:fake +28226 _string_81_subop_add/imm32/subx-name +28227 3/imm32/rm32-is-first-output +28228 0/imm32/no-r32 +28229 1/imm32/imm32-is-first-inout +28230 0/imm32/no-imm8 +28231 0/imm32/no-disp32 +28232 0/imm32/no-xm32 +28233 0/imm32/no-x32 +28234 0x11/imm32/alloc-id:fake +28235 _Primitive-add-lit-to-mem/imm32/next +28236 _Primitive-add-lit-to-mem: # (payload primitive) +28237 0x11/imm32/alloc-id:fake:payload +28238 # add-to var1, lit => 81 0/subop/add var1/rm32 lit/imm32 +28239 0x11/imm32/alloc-id:fake +28240 _string-add-to/imm32/name +28241 0x11/imm32/alloc-id:fake +28242 Int-var-and-literal/imm32/inouts 28243 0/imm32/no-outputs -28244 0x11/imm32/alloc-id:fake -28245 _string_81_subop_compare/imm32/subx-name -28246 1/imm32/rm32-is-first-inout -28247 0/imm32/no-r32 -28248 2/imm32/imm32-is-second-inout -28249 0/imm32/no-imm8 -28250 0/imm32/no-disp32 -28251 0/imm32/no-xm32 -28252 0/imm32/no-x32 -28253 0x11/imm32/alloc-id:fake -28254 _Primitive-negate-reg/imm32/next -28255 # - negate -28256 _Primitive-negate-reg: # (payload primitive) -28257 0x11/imm32/alloc-id:fake:payload -28258 # var1/reg <- negate => f7 3/subop/negate var1/rm32 -28259 0x11/imm32/alloc-id:fake -28260 _string-negate/imm32/name -28261 0/imm32/no-inouts -28262 0/imm32/no-inouts -28263 0x11/imm32/alloc-id:fake -28264 Single-int-var-in-some-register/imm32/outputs -28265 0x11/imm32/alloc-id:fake -28266 _string_f7_subop_negate/imm32/subx-name -28267 3/imm32/rm32-is-first-output -28268 0/imm32/no-r32 -28269 0/imm32/no-imm32 -28270 0/imm32/no-imm8 -28271 0/imm32/no-disp32 -28272 0/imm32/no-xm32 -28273 0/imm32/no-x32 -28274 0x11/imm32/alloc-id:fake -28275 _Primitive-negate-mem/imm32/next -28276 _Primitive-negate-mem: # (payload primitive) -28277 0x11/imm32/alloc-id:fake:payload -28278 # negate var1 => f7 3/subop/negate var1/rm32 -28279 0x11/imm32/alloc-id:fake -28280 _string-negate/imm32/name -28281 0x11/imm32/alloc-id:fake -28282 Single-int-var-in-mem/imm32/inouts -28283 0/imm32/no-outputs -28284 0/imm32/no-outputs -28285 0x11/imm32/alloc-id:fake -28286 _string_f7_subop_negate/imm32/subx-name -28287 1/imm32/rm32-is-first-inout -28288 0/imm32/no-r32 -28289 0/imm32/no-imm32 -28290 0/imm32/no-imm8 -28291 0/imm32/no-disp32 -28292 0/imm32/no-xm32 -28293 0/imm32/no-x32 -28294 0x11/imm32/alloc-id:fake -28295 _Primitive-multiply-reg-by-reg/imm32/next -28296 # - multiply -28297 _Primitive-multiply-reg-by-reg: # (payload primitive) +28244 0/imm32/no-outputs +28245 0x11/imm32/alloc-id:fake +28246 _string_81_subop_add/imm32/subx-name +28247 1/imm32/rm32-is-first-inout +28248 0/imm32/no-r32 +28249 2/imm32/imm32-is-second-inout +28250 0/imm32/no-imm8 +28251 0/imm32/no-disp32 +28252 0/imm32/no-xm32 +28253 0/imm32/no-x32 +28254 0x11/imm32/alloc-id:fake +28255 _Primitive-subtract-from-eax/imm32/next +28256 # - subtract +28257 _Primitive-subtract-from-eax: # (payload primitive) +28258 0x11/imm32/alloc-id:fake:payload +28259 # var/eax <- subtract lit => 2d/subtract-from-eax lit/imm32 +28260 0x11/imm32/alloc-id:fake +28261 _string-subtract/imm32/name +28262 0x11/imm32/alloc-id:fake +28263 Single-lit-var/imm32/inouts +28264 0x11/imm32/alloc-id:fake +28265 Single-int-var-in-eax/imm32/outputs +28266 0x11/imm32/alloc-id:fake +28267 _string_2d_subtract_from_eax/imm32/subx-name +28268 0/imm32/no-rm32 +28269 0/imm32/no-r32 +28270 1/imm32/imm32-is-first-inout +28271 0/imm32/no-imm8 +28272 0/imm32/no-disp32 +28273 0/imm32/no-xm32 +28274 0/imm32/no-x32 +28275 0x11/imm32/alloc-id:fake +28276 _Primitive-subtract-reg-from-reg/imm32/next +28277 _Primitive-subtract-reg-from-reg: # (payload primitive) +28278 0x11/imm32/alloc-id:fake:payload +28279 # var1/reg <- subtract var2/reg => 29/subtract-from var1/rm32 var2/r32 +28280 0x11/imm32/alloc-id:fake +28281 _string-subtract/imm32/name +28282 0x11/imm32/alloc-id:fake +28283 Single-int-var-in-some-register/imm32/inouts +28284 0x11/imm32/alloc-id:fake +28285 Single-int-var-in-some-register/imm32/outputs +28286 0x11/imm32/alloc-id:fake +28287 _string_29_subtract_from/imm32/subx-name +28288 3/imm32/rm32-is-first-output +28289 1/imm32/r32-is-first-inout +28290 0/imm32/no-imm32 +28291 0/imm32/no-imm8 +28292 0/imm32/no-disp32 +28293 0/imm32/no-xm32 +28294 0/imm32/no-x32 +28295 0x11/imm32/alloc-id:fake +28296 _Primitive-subtract-reg-from-mem/imm32/next +28297 _Primitive-subtract-reg-from-mem: # (payload primitive) 28298 0x11/imm32/alloc-id:fake:payload -28299 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 +28299 # subtract-from var1 var2/reg => 29/subtract-from var1 var2/r32 28300 0x11/imm32/alloc-id:fake -28301 _string-multiply/imm32/name +28301 _string-subtract-from/imm32/name 28302 0x11/imm32/alloc-id:fake -28303 Single-int-var-in-some-register/imm32/inouts -28304 0x11/imm32/alloc-id:fake -28305 Single-int-var-in-some-register/imm32/outputs +28303 Two-args-int-stack-int-reg/imm32/inouts +28304 0/imm32/no-outputs +28305 0/imm32/no-outputs 28306 0x11/imm32/alloc-id:fake -28307 _string_0f_af_multiply/imm32/subx-name +28307 _string_29_subtract_from/imm32/subx-name 28308 1/imm32/rm32-is-first-inout -28309 3/imm32/r32-is-first-output +28309 2/imm32/r32-is-second-inout 28310 0/imm32/no-imm32 28311 0/imm32/no-imm8 28312 0/imm32/no-disp32 28313 0/imm32/no-xm32 28314 0/imm32/no-x32 28315 0x11/imm32/alloc-id:fake -28316 _Primitive-multiply-reg-by-mem/imm32/next -28317 _Primitive-multiply-reg-by-mem: # (payload primitive) +28316 _Primitive-subtract-mem-from-reg/imm32/next +28317 _Primitive-subtract-mem-from-reg: # (payload primitive) 28318 0x11/imm32/alloc-id:fake:payload -28319 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 +28319 # var1/reg <- subtract var2 => 2b/subtract var2/rm32 var1/r32 28320 0x11/imm32/alloc-id:fake -28321 _string-multiply/imm32/name +28321 _string-subtract/imm32/name 28322 0x11/imm32/alloc-id:fake -28323 Single-int-var-in-mem/imm32/inouts +28323 Single-int-var-in-mem/imm32/inouts 28324 0x11/imm32/alloc-id:fake -28325 Single-int-var-in-some-register/imm32/outputs +28325 Single-int-var-in-some-register/imm32/outputs 28326 0x11/imm32/alloc-id:fake -28327 _string_0f_af_multiply/imm32/subx-name +28327 _string_2b_subtract/imm32/subx-name 28328 1/imm32/rm32-is-first-inout 28329 3/imm32/r32-is-first-output 28330 0/imm32/no-imm32 @@ -26883,6457 +26823,7486 @@ if ('onhashchange' in window) { 28333 0/imm32/no-xm32 28334 0/imm32/no-x32 28335 0x11/imm32/alloc-id:fake -28336 _Primitive-convert-mem-to-xreg/imm32/next -28337 # - convert int to floating point -28338 _Primitive-convert-mem-to-xreg: # (payload primitive) -28339 0x11/imm32/alloc-id:fake:payload -28340 # var1/xreg <- convert var2 => f3 0f 2a/convert-to-float var2/rm32 var1/x32 -28341 0x11/imm32/alloc-id:fake -28342 _string-convert/imm32/name -28343 0x11/imm32/alloc-id:fake -28344 Single-int-var-in-mem/imm32/inouts -28345 0x11/imm32/alloc-id:fake -28346 Single-float-var-in-some-register/imm32/outputs -28347 0x11/imm32/alloc-id:fake -28348 _string_f3_0f_2a_convert_to_float/imm32/subx-name -28349 1/imm32/rm32-is-first-inout -28350 0/imm32/no-r32 -28351 0/imm32/no-imm32 -28352 0/imm32/no-imm8 -28353 0/imm32/no-disp32 -28354 0/imm32/no-xm32 -28355 3/imm32/x32-is-first-output -28356 0x11/imm32/alloc-id:fake -28357 _Primitive-convert-reg-to-xreg/imm32/next -28358 _Primitive-convert-reg-to-xreg: # (payload primitive) -28359 0x11/imm32/alloc-id:fake:payload -28360 # var1/xreg <- convert var2/reg => f3 0f 2a/convert-to-float var2/rm32 var1/x32 -28361 0x11/imm32/alloc-id:fake -28362 _string-convert/imm32/name -28363 0x11/imm32/alloc-id:fake -28364 Single-int-var-in-some-register/imm32/inouts -28365 0x11/imm32/alloc-id:fake -28366 Single-float-var-in-some-register/imm32/outputs -28367 0x11/imm32/alloc-id:fake -28368 _string_f3_0f_2a_convert_to_float/imm32/subx-name -28369 1/imm32/rm32-is-first-inout -28370 0/imm32/no-r32 -28371 0/imm32/no-imm32 -28372 0/imm32/no-imm8 -28373 0/imm32/no-disp32 -28374 0/imm32/no-xm32 -28375 3/imm32/x32-is-first-output -28376 0x11/imm32/alloc-id:fake -28377 _Primitive-convert-xmem-to-reg/imm32/next -28378 # - convert floating point to int -28379 _Primitive-convert-xmem-to-reg: # (payload primitive) -28380 0x11/imm32/alloc-id:fake:payload -28381 # var1/reg <- convert var2 => f3 0f 2d/convert-to-int var2/xm32 var1/r32 -28382 0x11/imm32/alloc-id:fake -28383 _string-convert/imm32/name -28384 0x11/imm32/alloc-id:fake -28385 Single-float-var-in-mem/imm32/inouts -28386 0x11/imm32/alloc-id:fake -28387 Single-int-var-in-some-register/imm32/outputs -28388 0x11/imm32/alloc-id:fake -28389 _string_f3_0f_2d_convert_to_int/imm32/subx-name -28390 0/imm32/no-rm32 -28391 3/imm32/r32-is-first-output -28392 0/imm32/no-imm32 -28393 0/imm32/no-imm8 -28394 0/imm32/no-disp32 -28395 1/imm32/xm32-is-first-inout -28396 0/imm32/no-x32 -28397 0x11/imm32/alloc-id:fake -28398 _Primitive-convert-xreg-to-reg/imm32/next -28399 _Primitive-convert-xreg-to-reg: # (payload primitive) -28400 0x11/imm32/alloc-id:fake:payload -28401 # var1/reg <- convert var2/xreg => f3 0f 2d/convert-to-int var2/xm32 var1/r32 -28402 0x11/imm32/alloc-id:fake -28403 _string-convert/imm32/name -28404 0x11/imm32/alloc-id:fake -28405 Single-float-var-in-some-register/imm32/inouts -28406 0x11/imm32/alloc-id:fake -28407 Single-int-var-in-some-register/imm32/outputs -28408 0x11/imm32/alloc-id:fake -28409 _string_f3_0f_2d_convert_to_int/imm32/subx-name -28410 0/imm32/no-rm32 -28411 3/imm32/r32-is-first-output -28412 0/imm32/no-imm32 -28413 0/imm32/no-imm8 -28414 0/imm32/no-disp32 -28415 1/imm32/xm32-is-first-inout -28416 0/imm32/no-x32 -28417 0x11/imm32/alloc-id:fake -28418 _Primitive-truncate-xmem-to-reg/imm32/next -28419 _Primitive-truncate-xmem-to-reg: # (payload primitive) -28420 0x11/imm32/alloc-id:fake:payload -28421 # var1/reg <- truncate var2 => f3 0f 2c/truncate-to-int var2/xm32 var1/r32 -28422 0x11/imm32/alloc-id:fake -28423 _string-truncate/imm32/name -28424 0x11/imm32/alloc-id:fake -28425 Single-float-var-in-mem/imm32/inouts -28426 0x11/imm32/alloc-id:fake -28427 Single-int-var-in-some-register/imm32/outputs -28428 0x11/imm32/alloc-id:fake -28429 _string_f3_0f_2c_truncate_to_int/imm32/subx-name -28430 0/imm32/no-rm32 -28431 3/imm32/r32-is-first-output -28432 0/imm32/no-imm32 -28433 0/imm32/no-imm8 -28434 0/imm32/no-disp32 -28435 1/imm32/xm32-is-first-inout -28436 0/imm32/no-x32 -28437 0x11/imm32/alloc-id:fake -28438 _Primitive-truncate-xreg-to-reg/imm32/next -28439 _Primitive-truncate-xreg-to-reg: # (payload primitive) -28440 0x11/imm32/alloc-id:fake:payload -28441 # var1/reg <- truncate var2/xreg => f3 0f 2c/truncate-to-int var2/xm32 var1/r32 -28442 0x11/imm32/alloc-id:fake -28443 _string-truncate/imm32/name -28444 0x11/imm32/alloc-id:fake -28445 Single-float-var-in-some-register/imm32/inouts -28446 0x11/imm32/alloc-id:fake -28447 Single-int-var-in-some-register/imm32/outputs -28448 0x11/imm32/alloc-id:fake -28449 _string_f3_0f_2c_truncate_to_int/imm32/subx-name -28450 0/imm32/no-rm32 -28451 3/imm32/r32-is-first-output -28452 0/imm32/no-imm32 -28453 0/imm32/no-imm8 -28454 0/imm32/no-disp32 -28455 1/imm32/xm32-is-first-inout -28456 0/imm32/no-x32 -28457 0x11/imm32/alloc-id:fake -28458 _Primitive-reinterpret-xmem-as-reg/imm32/next -28459 # - reinterpret bytes (just for debugging) -28460 _Primitive-reinterpret-xmem-as-reg: # (payload primitive) -28461 0x11/imm32/alloc-id:fake:payload -28462 # var1/reg <- reinterpret var2 => 8b/-> var2/xm32 var1/r32 +28336 _Primitive-subtract-lit-from-reg/imm32/next +28337 _Primitive-subtract-lit-from-reg: # (payload primitive) +28338 0x11/imm32/alloc-id:fake:payload +28339 # var1/reg <- subtract lit => 81 5/subop/subtract var1/rm32 lit/imm32 +28340 0x11/imm32/alloc-id:fake +28341 _string-subtract/imm32/name +28342 0x11/imm32/alloc-id:fake +28343 Single-lit-var/imm32/inouts +28344 0x11/imm32/alloc-id:fake +28345 Single-int-var-in-some-register/imm32/outputs +28346 0x11/imm32/alloc-id:fake +28347 _string_81_subop_subtract/imm32/subx-name +28348 3/imm32/rm32-is-first-output +28349 0/imm32/no-r32 +28350 1/imm32/imm32-is-first-inout +28351 0/imm32/no-imm8 +28352 0/imm32/no-disp32 +28353 0/imm32/no-xm32 +28354 0/imm32/no-x32 +28355 0x11/imm32/alloc-id:fake +28356 _Primitive-subtract-lit-from-mem/imm32/next +28357 _Primitive-subtract-lit-from-mem: # (payload primitive) +28358 0x11/imm32/alloc-id:fake:payload +28359 # subtract-from var1, lit => 81 5/subop/subtract var1/rm32 lit/imm32 +28360 0x11/imm32/alloc-id:fake +28361 _string-subtract-from/imm32/name +28362 0x11/imm32/alloc-id:fake +28363 Int-var-and-literal/imm32/inouts +28364 0/imm32/no-outputs +28365 0/imm32/no-outputs +28366 0x11/imm32/alloc-id:fake +28367 _string_81_subop_subtract/imm32/subx-name +28368 1/imm32/rm32-is-first-inout +28369 0/imm32/no-r32 +28370 2/imm32/imm32-is-second-inout +28371 0/imm32/no-imm8 +28372 0/imm32/no-disp32 +28373 0/imm32/no-xm32 +28374 0/imm32/no-x32 +28375 0x11/imm32/alloc-id:fake +28376 _Primitive-and-with-eax/imm32/next +28377 # - and +28378 _Primitive-and-with-eax: # (payload primitive) +28379 0x11/imm32/alloc-id:fake:payload +28380 # var/eax <- and lit => 25/and-with-eax lit/imm32 +28381 0x11/imm32/alloc-id:fake +28382 _string-and/imm32/name +28383 0x11/imm32/alloc-id:fake +28384 Single-lit-var/imm32/inouts +28385 0x11/imm32/alloc-id:fake +28386 Single-int-var-in-eax/imm32/outputs +28387 0x11/imm32/alloc-id:fake +28388 _string_25_and_with_eax/imm32/subx-name +28389 0/imm32/no-rm32 +28390 0/imm32/no-r32 +28391 1/imm32/imm32-is-first-inout +28392 0/imm32/no-imm8 +28393 0/imm32/no-disp32 +28394 0/imm32/no-xm32 +28395 0/imm32/no-x32 +28396 0x11/imm32/alloc-id:fake +28397 _Primitive-and-reg-with-reg/imm32/next +28398 _Primitive-and-reg-with-reg: # (payload primitive) +28399 0x11/imm32/alloc-id:fake:payload +28400 # var1/reg <- and var2/reg => 21/and-with var1/rm32 var2/r32 +28401 0x11/imm32/alloc-id:fake +28402 _string-and/imm32/name +28403 0x11/imm32/alloc-id:fake +28404 Single-int-var-in-some-register/imm32/inouts +28405 0x11/imm32/alloc-id:fake +28406 Single-int-var-in-some-register/imm32/outputs +28407 0x11/imm32/alloc-id:fake +28408 _string_21_and_with/imm32/subx-name +28409 3/imm32/rm32-is-first-output +28410 1/imm32/r32-is-first-inout +28411 0/imm32/no-imm32 +28412 0/imm32/no-imm8 +28413 0/imm32/no-disp32 +28414 0/imm32/no-xm32 +28415 0/imm32/no-x32 +28416 0x11/imm32/alloc-id:fake +28417 _Primitive-and-reg-with-mem/imm32/next +28418 _Primitive-and-reg-with-mem: # (payload primitive) +28419 0x11/imm32/alloc-id:fake:payload +28420 # and-with var1 var2/reg => 21/and-with var1 var2/r32 +28421 0x11/imm32/alloc-id:fake +28422 _string-and-with/imm32/name +28423 0x11/imm32/alloc-id:fake +28424 Two-args-int-stack-int-reg/imm32/inouts +28425 0/imm32/no-outputs +28426 0/imm32/no-outputs +28427 0x11/imm32/alloc-id:fake +28428 _string_21_and_with/imm32/subx-name +28429 1/imm32/rm32-is-first-inout +28430 2/imm32/r32-is-second-inout +28431 0/imm32/no-imm32 +28432 0/imm32/no-imm8 +28433 0/imm32/no-disp32 +28434 0/imm32/no-xm32 +28435 0/imm32/no-x32 +28436 0x11/imm32/alloc-id:fake +28437 _Primitive-and-mem-with-reg/imm32/next +28438 _Primitive-and-mem-with-reg: # (payload primitive) +28439 0x11/imm32/alloc-id:fake:payload +28440 # var1/reg <- and var2 => 23/and var2/rm32 var1/r32 +28441 0x11/imm32/alloc-id:fake +28442 _string-and/imm32/name +28443 0x11/imm32/alloc-id:fake +28444 Single-int-var-in-mem/imm32/inouts +28445 0x11/imm32/alloc-id:fake +28446 Single-int-var-in-some-register/imm32/outputs +28447 0x11/imm32/alloc-id:fake +28448 _string_23_and/imm32/subx-name +28449 1/imm32/rm32-is-first-inout +28450 3/imm32/r32-is-first-output +28451 0/imm32/no-imm32 +28452 0/imm32/no-imm8 +28453 0/imm32/no-disp32 +28454 0/imm32/no-xm32 +28455 0/imm32/no-x32 +28456 0x11/imm32/alloc-id:fake +28457 _Primitive-and-lit-with-reg/imm32/next +28458 _Primitive-and-lit-with-reg: # (payload primitive) +28459 0x11/imm32/alloc-id:fake:payload +28460 # var1/reg <- and lit => 81 4/subop/and var1/rm32 lit/imm32 +28461 0x11/imm32/alloc-id:fake +28462 _string-and/imm32/name 28463 0x11/imm32/alloc-id:fake -28464 _string-reinterpret/imm32/name +28464 Single-lit-var/imm32/inouts 28465 0x11/imm32/alloc-id:fake -28466 Single-float-var-in-mem/imm32/inouts +28466 Single-int-var-in-some-register/imm32/outputs 28467 0x11/imm32/alloc-id:fake -28468 Single-int-var-in-some-register/imm32/outputs -28469 0x11/imm32/alloc-id:fake -28470 _string_8b_->/imm32/subx-name -28471 0/imm32/no-rm32 -28472 3/imm32/r32-is-first-output -28473 0/imm32/no-imm32 -28474 0/imm32/no-imm8 -28475 0/imm32/no-disp32 -28476 1/imm32/xm32-is-first-inout -28477 0/imm32/no-x32 -28478 0x11/imm32/alloc-id:fake -28479 _Primitive-reinterpret-mem-as-xreg/imm32/next -28480 _Primitive-reinterpret-mem-as-xreg: # (payload primitive) -28481 0x11/imm32/alloc-id:fake:payload -28482 # var1/xreg <- reinterpret var2 => f3 0f 10/-> var2/rm32 var1/x32 +28468 _string_81_subop_and/imm32/subx-name +28469 3/imm32/rm32-is-first-output +28470 0/imm32/no-r32 +28471 1/imm32/imm32-is-first-inout +28472 0/imm32/no-imm8 +28473 0/imm32/no-disp32 +28474 0/imm32/no-xm32 +28475 0/imm32/no-x32 +28476 0x11/imm32/alloc-id:fake +28477 _Primitive-and-lit-with-mem/imm32/next +28478 _Primitive-and-lit-with-mem: # (payload primitive) +28479 0x11/imm32/alloc-id:fake:payload +28480 # and-with var1, lit => 81 4/subop/and var1/rm32 lit/imm32 +28481 0x11/imm32/alloc-id:fake +28482 _string-and-with/imm32/name 28483 0x11/imm32/alloc-id:fake -28484 _string-reinterpret/imm32/name -28485 0x11/imm32/alloc-id:fake -28486 Single-int-var-in-mem/imm32/inouts +28484 Int-var-and-literal/imm32/inouts +28485 0/imm32/no-outputs +28486 0/imm32/no-outputs 28487 0x11/imm32/alloc-id:fake -28488 Single-float-var-in-some-register/imm32/outputs -28489 0x11/imm32/alloc-id:fake -28490 _string_f3_0f_10_copy/imm32/subx-name -28491 1/imm32/rm32-is-first-inout -28492 0/imm32/no-r32 -28493 0/imm32/no-imm32 -28494 0/imm32/no-imm8 -28495 0/imm32/no-disp32 -28496 0/imm32/no-xm32 -28497 3/imm32/x32-is-first-output -28498 0x11/imm32/alloc-id:fake -28499 _Primitive-copy-xreg-to-xreg/imm32/next -28500 # - floating-point copy -28501 _Primitive-copy-xreg-to-xreg: # (payload primitive) -28502 0x11/imm32/alloc-id:fake:payload -28503 # var1/xreg <- copy var2/xreg => f3 0f 11/<- var1/xm32 var2/x32 +28488 _string_81_subop_and/imm32/subx-name +28489 1/imm32/rm32-is-first-inout +28490 0/imm32/no-r32 +28491 2/imm32/imm32-is-second-inout +28492 0/imm32/no-imm8 +28493 0/imm32/no-disp32 +28494 0/imm32/no-xm32 +28495 0/imm32/no-x32 +28496 0x11/imm32/alloc-id:fake +28497 _Primitive-or-with-eax/imm32/next +28498 # - or +28499 _Primitive-or-with-eax: # (payload primitive) +28500 0x11/imm32/alloc-id:fake:payload +28501 # var/eax <- or lit => 0d/or-with-eax lit/imm32 +28502 0x11/imm32/alloc-id:fake +28503 _string-or/imm32/name 28504 0x11/imm32/alloc-id:fake -28505 _string-copy/imm32/name +28505 Single-lit-var/imm32/inouts 28506 0x11/imm32/alloc-id:fake -28507 Single-float-var-in-some-register/imm32/inouts +28507 Single-int-var-in-eax/imm32/outputs 28508 0x11/imm32/alloc-id:fake -28509 Single-float-var-in-some-register/imm32/outputs -28510 0x11/imm32/alloc-id:fake -28511 _string_f3_0f_11_copy/imm32/subx-name -28512 0/imm32/no-rm32 -28513 0/imm32/no-r32 -28514 0/imm32/no-imm32 -28515 0/imm32/no-imm8 -28516 0/imm32/no-disp32 -28517 3/imm32/xm32-is-first-output -28518 1/imm32/x32-is-first-inout -28519 0x11/imm32/alloc-id:fake -28520 _Primitive-copy-xreg-to-mem/imm32/next -28521 _Primitive-copy-xreg-to-mem: # (payload primitive) -28522 0x11/imm32/alloc-id:fake:payload -28523 # copy-to var1 var2/xreg => f3 0f 11/<- var1 var2/x32 +28509 _string_0d_or_with_eax/imm32/subx-name +28510 0/imm32/no-rm32 +28511 0/imm32/no-r32 +28512 1/imm32/imm32-is-first-inout +28513 0/imm32/no-imm8 +28514 0/imm32/no-disp32 +28515 0/imm32/no-xm32 +28516 0/imm32/no-x32 +28517 0x11/imm32/alloc-id:fake +28518 _Primitive-or-reg-with-reg/imm32/next +28519 _Primitive-or-reg-with-reg: # (payload primitive) +28520 0x11/imm32/alloc-id:fake:payload +28521 # var1/reg <- or var2/reg => 09/or-with var1/rm32 var2/r32 +28522 0x11/imm32/alloc-id:fake +28523 _string-or/imm32/name 28524 0x11/imm32/alloc-id:fake -28525 _string-copy-to/imm32/name +28525 Single-int-var-in-some-register/imm32/inouts 28526 0x11/imm32/alloc-id:fake -28527 Two-args-float-stack-float-reg/imm32/inouts -28528 0/imm32/no-outputs -28529 0/imm32/no-outputs -28530 0x11/imm32/alloc-id:fake -28531 _string_f3_0f_11_copy/imm32/subx-name -28532 0/imm32/no-rm32 -28533 0/imm32/no-r32 -28534 0/imm32/no-imm32 -28535 0/imm32/no-imm8 -28536 0/imm32/no-disp32 -28537 1/imm32/xm32-is-first-inout -28538 2/imm32/x32-is-second-inout -28539 0x11/imm32/alloc-id:fake -28540 _Primitive-copy-mem-to-xreg/imm32/next -28541 _Primitive-copy-mem-to-xreg: # (payload primitive) -28542 0x11/imm32/alloc-id:fake:payload -28543 # var1/xreg <- copy var2 => f3 0f 10/-> var2/rm32 var1/x32 +28527 Single-int-var-in-some-register/imm32/outputs +28528 0x11/imm32/alloc-id:fake +28529 _string_09_or_with/imm32/subx-name +28530 3/imm32/rm32-is-first-output +28531 1/imm32/r32-is-first-inout +28532 0/imm32/no-imm32 +28533 0/imm32/no-imm8 +28534 0/imm32/no-disp32 +28535 0/imm32/no-xm32 +28536 0/imm32/no-x32 +28537 0x11/imm32/alloc-id:fake +28538 _Primitive-or-reg-with-mem/imm32/next +28539 _Primitive-or-reg-with-mem: # (payload primitive) +28540 0x11/imm32/alloc-id:fake:payload +28541 # or-with var1 var2/reg => 09/or-with var1 var2/r32 +28542 0x11/imm32/alloc-id:fake +28543 _string-or-with/imm32/name 28544 0x11/imm32/alloc-id:fake -28545 _string-copy/imm32/name -28546 0x11/imm32/alloc-id:fake -28547 Single-float-var-in-mem/imm32/inouts +28545 Two-args-int-stack-int-reg/imm32/inouts +28546 0/imm32/no-outputs +28547 0/imm32/no-outputs 28548 0x11/imm32/alloc-id:fake -28549 Single-float-var-in-some-register/imm32/outputs -28550 0x11/imm32/alloc-id:fake -28551 _string_f3_0f_10_copy/imm32/subx-name -28552 0/imm32/no-rm32 -28553 0/imm32/no-r32 -28554 0/imm32/no-imm32 -28555 0/imm32/no-imm8 -28556 0/imm32/no-disp32 -28557 1/imm32/xm32-is-first-inout -28558 3/imm32/x32-is-first-output -28559 0x11/imm32/alloc-id:fake -28560 _Primitive-address-of-xmem/imm32/next -28561 # - floating-point-address -28562 _Primitive-address-of-xmem: # (payload primitive) -28563 0x11/imm32/alloc-id:fake:payload -28564 # var1/reg <- address var2 => 8d/copy-address var2/rm32 var1/r32 -28565 0x11/imm32/alloc-id:fake -28566 _string-address/imm32/name -28567 0x11/imm32/alloc-id:fake -28568 Single-float-var-in-mem/imm32/inouts -28569 0x11/imm32/alloc-id:fake -28570 Single-addr-var-in-some-register/imm32/outputs -28571 0x11/imm32/alloc-id:fake -28572 _string_8d_copy_address/imm32/subx-name -28573 1/imm32/rm32-is-first-inout -28574 3/imm32/r32-is-first-output -28575 0/imm32/no-imm32 -28576 0/imm32/no-imm8 -28577 0/imm32/no-disp32 -28578 0/imm32/no-xm32 -28579 0/imm32/no-x32 -28580 0x11/imm32/alloc-id:fake -28581 _Primitive-add-xreg-to-xreg/imm32/next -28582 # - floating-point add -28583 _Primitive-add-xreg-to-xreg: # (payload primitive) -28584 0x11/imm32/alloc-id:fake:payload -28585 # var1/xreg <- add var2/xreg => f3 0f 58/add var1/xm32 var2/x32 +28549 _string_09_or_with/imm32/subx-name +28550 1/imm32/rm32-is-first-inout +28551 2/imm32/r32-is-second-inout +28552 0/imm32/no-imm32 +28553 0/imm32/no-imm8 +28554 0/imm32/no-disp32 +28555 0/imm32/no-xm32 +28556 0/imm32/no-x32 +28557 0x11/imm32/alloc-id:fake +28558 _Primitive-or-mem-with-reg/imm32/next +28559 _Primitive-or-mem-with-reg: # (payload primitive) +28560 0x11/imm32/alloc-id:fake:payload +28561 # var1/reg <- or var2 => 0b/or var2/rm32 var1/r32 +28562 0x11/imm32/alloc-id:fake +28563 _string-or/imm32/name +28564 0x11/imm32/alloc-id:fake +28565 Single-int-var-in-mem/imm32/inouts +28566 0x11/imm32/alloc-id:fake +28567 Single-int-var-in-some-register/imm32/outputs +28568 0x11/imm32/alloc-id:fake +28569 _string_0b_or/imm32/subx-name +28570 1/imm32/rm32-is-first-inout +28571 3/imm32/r32-is-first-output +28572 0/imm32/no-imm32 +28573 0/imm32/no-imm8 +28574 0/imm32/no-disp32 +28575 0/imm32/no-xm32 +28576 0/imm32/no-x32 +28577 0x11/imm32/alloc-id:fake +28578 _Primitive-or-lit-with-reg/imm32/next +28579 _Primitive-or-lit-with-reg: # (payload primitive) +28580 0x11/imm32/alloc-id:fake:payload +28581 # var1/reg <- or lit => 81 1/subop/or var1/rm32 lit/imm32 +28582 0x11/imm32/alloc-id:fake +28583 _string-or/imm32/name +28584 0x11/imm32/alloc-id:fake +28585 Single-lit-var/imm32/inouts 28586 0x11/imm32/alloc-id:fake -28587 _string-add/imm32/name +28587 Single-int-var-in-some-register/imm32/outputs 28588 0x11/imm32/alloc-id:fake -28589 Single-float-var-in-some-register/imm32/inouts -28590 0x11/imm32/alloc-id:fake -28591 Single-float-var-in-some-register/imm32/outputs -28592 0x11/imm32/alloc-id:fake -28593 _string_f3_0f_58_add/imm32/subx-name -28594 0/imm32/no-rm32 -28595 0/imm32/no-r32 -28596 0/imm32/no-imm32 -28597 0/imm32/no-imm8 -28598 0/imm32/no-disp32 -28599 1/imm32/xm32-is-first-inout -28600 3/imm32/x32-is-first-output -28601 0x11/imm32/alloc-id:fake -28602 _Primitive-add-mem-to-xreg/imm32/next -28603 _Primitive-add-mem-to-xreg: # (payload primitive) -28604 0x11/imm32/alloc-id:fake:payload -28605 # var1/xreg <- add var2 => f3 0f 58/add var2/xm32 var1/x32 -28606 0x11/imm32/alloc-id:fake -28607 _string-add/imm32/name +28589 _string_81_subop_or/imm32/subx-name +28590 3/imm32/rm32-is-first-output +28591 0/imm32/no-r32 +28592 1/imm32/imm32-is-first-inout +28593 0/imm32/no-imm8 +28594 0/imm32/no-disp32 +28595 0/imm32/no-xm32 +28596 0/imm32/no-x32 +28597 0x11/imm32/alloc-id:fake +28598 _Primitive-or-lit-with-mem/imm32/next +28599 _Primitive-or-lit-with-mem: # (payload primitive) +28600 0x11/imm32/alloc-id:fake:payload +28601 # or-with var1, lit => 81 1/subop/or var1/rm32 lit/imm32 +28602 0x11/imm32/alloc-id:fake +28603 _string-or-with/imm32/name +28604 0x11/imm32/alloc-id:fake +28605 Int-var-and-literal/imm32/inouts +28606 0/imm32/no-outputs +28607 0/imm32/no-outputs 28608 0x11/imm32/alloc-id:fake -28609 Single-float-var-in-mem/imm32/inouts -28610 0x11/imm32/alloc-id:fake -28611 Single-float-var-in-some-register/imm32/outputs -28612 0x11/imm32/alloc-id:fake -28613 _string_f3_0f_58_add/imm32/subx-name -28614 0/imm32/no-rm32 -28615 0/imm32/no-r32 -28616 0/imm32/no-imm32 -28617 0/imm32/no-imm8 -28618 0/imm32/no-disp32 -28619 1/imm32/xm32-is-first-inout -28620 3/imm32/x32-is-first-output -28621 0x11/imm32/alloc-id:fake -28622 _Primitive-subtract-xreg-from-xreg/imm32/next -28623 # - floating-point subtract -28624 _Primitive-subtract-xreg-from-xreg: # (payload primitive) -28625 0x11/imm32/alloc-id:fake:payload -28626 # var1/xreg <- subtract var2/xreg => f3 0f 5c/subtract var1/xm32 var2/x32 +28609 _string_81_subop_or/imm32/subx-name +28610 1/imm32/rm32-is-first-inout +28611 0/imm32/no-r32 +28612 2/imm32/imm32-is-second-inout +28613 0/imm32/no-imm8 +28614 0/imm32/no-disp32 +28615 0/imm32/no-xm32 +28616 0/imm32/no-x32 +28617 0x11/imm32/alloc-id:fake +28618 _Primitive-xor-with-eax/imm32/next +28619 # - xor +28620 _Primitive-xor-with-eax: # (payload primitive) +28621 0x11/imm32/alloc-id:fake:payload +28622 # var/eax <- xor lit => 35/xor-with-eax lit/imm32 +28623 0x11/imm32/alloc-id:fake +28624 _string-xor/imm32/name +28625 0x11/imm32/alloc-id:fake +28626 Single-lit-var/imm32/inouts 28627 0x11/imm32/alloc-id:fake -28628 _string-subtract/imm32/name +28628 Single-int-var-in-eax/imm32/outputs 28629 0x11/imm32/alloc-id:fake -28630 Single-float-var-in-some-register/imm32/inouts -28631 0x11/imm32/alloc-id:fake -28632 Single-float-var-in-some-register/imm32/outputs -28633 0x11/imm32/alloc-id:fake -28634 _string_f3_0f_5c_subtract/imm32/subx-name -28635 0/imm32/no-rm32 -28636 0/imm32/no-r32 -28637 0/imm32/no-imm32 -28638 0/imm32/no-imm8 -28639 0/imm32/no-disp32 -28640 1/imm32/xm32-is-first-inout -28641 3/imm32/x32-is-first-output -28642 0x11/imm32/alloc-id:fake -28643 _Primitive-subtract-mem-from-xreg/imm32/next -28644 _Primitive-subtract-mem-from-xreg: # (payload primitive) -28645 0x11/imm32/alloc-id:fake:payload -28646 # var1/xreg <- subtract var2 => f3 0f 5c/subtract var2/xm32 var1/x32 +28630 _string_35_xor_with_eax/imm32/subx-name +28631 0/imm32/no-rm32 +28632 0/imm32/no-r32 +28633 1/imm32/imm32-is-first-inout +28634 0/imm32/no-imm8 +28635 0/imm32/no-disp32 +28636 0/imm32/no-xm32 +28637 0/imm32/no-x32 +28638 0x11/imm32/alloc-id:fake +28639 _Primitive-xor-reg-with-reg/imm32/next +28640 _Primitive-xor-reg-with-reg: # (payload primitive) +28641 0x11/imm32/alloc-id:fake:payload +28642 # var1/reg <- xor var2/reg => 31/xor-with var1/rm32 var2/r32 +28643 0x11/imm32/alloc-id:fake +28644 _string-xor/imm32/name +28645 0x11/imm32/alloc-id:fake +28646 Single-int-var-in-some-register/imm32/inouts 28647 0x11/imm32/alloc-id:fake -28648 _string-subtract/imm32/name +28648 Single-int-var-in-some-register/imm32/outputs 28649 0x11/imm32/alloc-id:fake -28650 Single-float-var-in-mem/imm32/inouts -28651 0x11/imm32/alloc-id:fake -28652 Single-float-var-in-some-register/imm32/outputs -28653 0x11/imm32/alloc-id:fake -28654 _string_f3_0f_5c_subtract/imm32/subx-name -28655 0/imm32/no-rm32 -28656 0/imm32/no-r32 -28657 0/imm32/no-imm32 -28658 0/imm32/no-imm8 -28659 0/imm32/no-disp32 -28660 1/imm32/xm32-is-first-inout -28661 3/imm32/x32-is-first-output -28662 0x11/imm32/alloc-id:fake -28663 _Primitive-multiply-xreg-by-xreg/imm32/next -28664 # - floating-point multiply -28665 _Primitive-multiply-xreg-by-xreg: # (payload primitive) -28666 0x11/imm32/alloc-id:fake:payload -28667 # var1/xreg <- multiply var2 => f3 0f 59/multiply var2/xm32 var1/x32 -28668 0x11/imm32/alloc-id:fake -28669 _string-multiply/imm32/name -28670 0x11/imm32/alloc-id:fake -28671 Single-float-var-in-some-register/imm32/inouts -28672 0x11/imm32/alloc-id:fake -28673 Single-float-var-in-some-register/imm32/outputs -28674 0x11/imm32/alloc-id:fake -28675 _string_f3_0f_59_multiply/imm32/subx-name -28676 0/imm32/no-rm32 -28677 0/imm32/no-r32 -28678 0/imm32/no-imm32 -28679 0/imm32/no-imm8 -28680 0/imm32/no-disp32 -28681 1/imm32/xm32-is-first-inout -28682 3/imm32/x32-is-first-output +28650 _string_31_xor_with/imm32/subx-name +28651 3/imm32/rm32-is-first-output +28652 1/imm32/r32-is-first-inout +28653 0/imm32/no-imm32 +28654 0/imm32/no-imm8 +28655 0/imm32/no-disp32 +28656 0/imm32/no-xm32 +28657 0/imm32/no-x32 +28658 0x11/imm32/alloc-id:fake +28659 _Primitive-xor-reg-with-mem/imm32/next +28660 _Primitive-xor-reg-with-mem: # (payload primitive) +28661 0x11/imm32/alloc-id:fake:payload +28662 # xor-with var1 var2/reg => 31/xor-with var1 var2/r32 +28663 0x11/imm32/alloc-id:fake +28664 _string-xor-with/imm32/name +28665 0x11/imm32/alloc-id:fake +28666 Two-args-int-stack-int-reg/imm32/inouts +28667 0/imm32/no-outputs +28668 0/imm32/no-outputs +28669 0x11/imm32/alloc-id:fake +28670 _string_31_xor_with/imm32/subx-name +28671 1/imm32/rm32-is-first-inout +28672 2/imm32/r32-is-second-inout +28673 0/imm32/no-imm32 +28674 0/imm32/no-imm8 +28675 0/imm32/no-disp32 +28676 0/imm32/no-xm32 +28677 0/imm32/no-x32 +28678 0x11/imm32/alloc-id:fake +28679 _Primitive-xor-mem-with-reg/imm32/next +28680 _Primitive-xor-mem-with-reg: # (payload primitive) +28681 0x11/imm32/alloc-id:fake:payload +28682 # var1/reg <- xor var2 => 33/xor var2/rm32 var1/r32 28683 0x11/imm32/alloc-id:fake -28684 _Primitive-multiply-xreg-by-mem/imm32/next -28685 _Primitive-multiply-xreg-by-mem: # (payload primitive) -28686 0x11/imm32/alloc-id:fake:payload -28687 # var1/xreg <- multiply var2 => 53 0f 59/multiply var2/xm32 var1/x32 -28688 0x11/imm32/alloc-id:fake -28689 _string-multiply/imm32/name -28690 0x11/imm32/alloc-id:fake -28691 Single-float-var-in-mem/imm32/inouts -28692 0x11/imm32/alloc-id:fake -28693 Single-float-var-in-some-register/imm32/outputs -28694 0x11/imm32/alloc-id:fake -28695 _string_f3_0f_59_multiply/imm32/subx-name -28696 0/imm32/no-rm32 -28697 0/imm32/no-r32 -28698 0/imm32/no-imm32 -28699 0/imm32/no-imm8 -28700 0/imm32/no-disp32 -28701 1/imm32/xm32-is-first-inout -28702 3/imm32/x32-is-first-output +28684 _string-xor/imm32/name +28685 0x11/imm32/alloc-id:fake +28686 Single-int-var-in-mem/imm32/inouts +28687 0x11/imm32/alloc-id:fake +28688 Single-int-var-in-some-register/imm32/outputs +28689 0x11/imm32/alloc-id:fake +28690 _string_33_xor/imm32/subx-name +28691 1/imm32/rm32-is-first-inout +28692 3/imm32/r32-is-first-output +28693 0/imm32/no-imm32 +28694 0/imm32/no-imm8 +28695 0/imm32/no-disp32 +28696 0/imm32/no-xm32 +28697 0/imm32/no-x32 +28698 0x11/imm32/alloc-id:fake +28699 _Primitive-xor-lit-with-reg/imm32/next +28700 _Primitive-xor-lit-with-reg: # (payload primitive) +28701 0x11/imm32/alloc-id:fake:payload +28702 # var1/reg <- xor lit => 81 6/subop/xor var1/rm32 lit/imm32 28703 0x11/imm32/alloc-id:fake -28704 _Primitive-divide-xreg-by-xreg/imm32/next -28705 # - floating-point divide -28706 _Primitive-divide-xreg-by-xreg: # (payload primitive) -28707 0x11/imm32/alloc-id:fake:payload -28708 # var1/xreg <- divide var2 => f3 0f 5e/divide var2/xm32 var1/x32 +28704 _string-xor/imm32/name +28705 0x11/imm32/alloc-id:fake +28706 Single-lit-var/imm32/inouts +28707 0x11/imm32/alloc-id:fake +28708 Single-int-var-in-some-register/imm32/outputs 28709 0x11/imm32/alloc-id:fake -28710 _string-divide/imm32/name -28711 0x11/imm32/alloc-id:fake -28712 Single-float-var-in-some-register/imm32/inouts -28713 0x11/imm32/alloc-id:fake -28714 Single-float-var-in-some-register/imm32/outputs -28715 0x11/imm32/alloc-id:fake -28716 _string_f3_0f_5e_divide/imm32/subx-name -28717 0/imm32/no-rm32 -28718 0/imm32/no-r32 -28719 0/imm32/no-imm32 -28720 0/imm32/no-imm8 -28721 0/imm32/no-disp32 -28722 1/imm32/xm32-is-first-inout -28723 3/imm32/x32-is-first-output -28724 0x11/imm32/alloc-id:fake -28725 _Primitive-divide-xreg-by-mem/imm32/next -28726 _Primitive-divide-xreg-by-mem: # (payload primitive) -28727 0x11/imm32/alloc-id:fake:payload -28728 # var1/xreg <- divide var2 => f3 0f 5e/divide var2/xm32 var1/x32 +28710 _string_81_subop_xor/imm32/subx-name +28711 3/imm32/rm32-is-first-output +28712 0/imm32/no-r32 +28713 1/imm32/imm32-is-first-inout +28714 0/imm32/no-imm8 +28715 0/imm32/no-disp32 +28716 0/imm32/no-xm32 +28717 0/imm32/no-x32 +28718 0x11/imm32/alloc-id:fake +28719 _Primitive-xor-lit-with-mem/imm32/next +28720 _Primitive-xor-lit-with-mem: # (payload primitive) +28721 0x11/imm32/alloc-id:fake:payload +28722 # xor-with var1, lit => 81 6/subop/xor var1/rm32 lit/imm32 +28723 0x11/imm32/alloc-id:fake +28724 _string-xor-with/imm32/name +28725 0x11/imm32/alloc-id:fake +28726 Int-var-and-literal/imm32/inouts +28727 0/imm32/no-outputs +28728 0/imm32/no-outputs 28729 0x11/imm32/alloc-id:fake -28730 _string-divide/imm32/name -28731 0x11/imm32/alloc-id:fake -28732 Single-float-var-in-mem/imm32/inouts -28733 0x11/imm32/alloc-id:fake -28734 Single-float-var-in-some-register/imm32/outputs -28735 0x11/imm32/alloc-id:fake -28736 _string_f3_0f_5e_divide/imm32/subx-name -28737 0/imm32/no-rm32 -28738 0/imm32/no-r32 -28739 0/imm32/no-imm32 -28740 0/imm32/no-imm8 -28741 0/imm32/no-disp32 -28742 1/imm32/xm32-is-first-inout -28743 3/imm32/x32-is-first-output -28744 0x11/imm32/alloc-id:fake -28745 _Primitive-max-xreg-with-xreg/imm32/next -28746 # - floating-point maximum -28747 _Primitive-max-xreg-with-xreg: # (payload primitive) -28748 0x11/imm32/alloc-id:fake:payload -28749 # var1/xreg <- max var2 => f3 0f 5f/max var2/xm32 var1/x32 -28750 0x11/imm32/alloc-id:fake -28751 _string-max/imm32/name -28752 0x11/imm32/alloc-id:fake -28753 Single-float-var-in-some-register/imm32/inouts -28754 0x11/imm32/alloc-id:fake -28755 Single-float-var-in-some-register/imm32/outputs -28756 0x11/imm32/alloc-id:fake -28757 _string_f3_0f_5f_max/imm32/subx-name -28758 0/imm32/no-rm32 -28759 0/imm32/no-r32 -28760 0/imm32/no-imm32 -28761 0/imm32/no-imm8 -28762 0/imm32/no-disp32 -28763 1/imm32/xm32-is-first-inout -28764 3/imm32/x32-is-first-output +28730 _string_81_subop_xor/imm32/subx-name +28731 1/imm32/rm32-is-first-inout +28732 0/imm32/no-r32 +28733 2/imm32/imm32-is-second-inout +28734 0/imm32/no-imm8 +28735 0/imm32/no-disp32 +28736 0/imm32/no-xm32 +28737 0/imm32/no-x32 +28738 0x11/imm32/alloc-id:fake +28739 _Primitive-shift-reg-left-by-lit/imm32/next +28740 _Primitive-shift-reg-left-by-lit: # (payload primitive) +28741 0x11/imm32/alloc-id:fake:payload +28742 # var1/reg <- shift-left lit => c1/shift 4/subop/left var1/rm32 lit/imm32 +28743 0x11/imm32/alloc-id:fake +28744 _string-shift-left/imm32/name +28745 0x11/imm32/alloc-id:fake +28746 Single-lit-var/imm32/inouts +28747 0x11/imm32/alloc-id:fake +28748 Single-int-var-in-some-register/imm32/outputs +28749 0x11/imm32/alloc-id:fake +28750 _string_c1_subop_shift_left/imm32/subx-name +28751 3/imm32/rm32-is-first-output +28752 0/imm32/no-r32 +28753 0/imm32/no-imm32 +28754 1/imm32/imm8-is-first-inout +28755 0/imm32/no-disp32 +28756 0/imm32/no-xm32 +28757 0/imm32/no-x32 +28758 0x11/imm32/alloc-id:fake +28759 _Primitive-shift-reg-right-by-lit/imm32/next +28760 _Primitive-shift-reg-right-by-lit: # (payload primitive) +28761 0x11/imm32/alloc-id:fake:payload +28762 # var1/reg <- shift-right lit => c1/shift 5/subop/right var1/rm32 lit/imm32 +28763 0x11/imm32/alloc-id:fake +28764 _string-shift-right/imm32/name 28765 0x11/imm32/alloc-id:fake -28766 _Primitive-max-xreg-with-mem/imm32/next -28767 _Primitive-max-xreg-with-mem: # (payload primitive) -28768 0x11/imm32/alloc-id:fake:payload -28769 # var1/xreg <- divide var2 => f3 0f 5f/max var2/xm32 var1/x32 -28770 0x11/imm32/alloc-id:fake -28771 _string-max/imm32/name -28772 0x11/imm32/alloc-id:fake -28773 Single-float-var-in-mem/imm32/inouts -28774 0x11/imm32/alloc-id:fake -28775 Single-float-var-in-some-register/imm32/outputs -28776 0x11/imm32/alloc-id:fake -28777 _string_f3_0f_5f_max/imm32/subx-name -28778 0/imm32/no-rm32 -28779 0/imm32/no-r32 -28780 0/imm32/no-imm32 -28781 0/imm32/no-imm8 -28782 0/imm32/no-disp32 -28783 1/imm32/xm32-is-first-inout -28784 3/imm32/x32-is-first-output +28766 Single-lit-var/imm32/inouts +28767 0x11/imm32/alloc-id:fake +28768 Single-int-var-in-some-register/imm32/outputs +28769 0x11/imm32/alloc-id:fake +28770 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name +28771 3/imm32/rm32-is-first-output +28772 0/imm32/no-r32 +28773 0/imm32/no-imm32 +28774 1/imm32/imm8-is-first-inout +28775 0/imm32/no-disp32 +28776 0/imm32/no-xm32 +28777 0/imm32/no-x32 +28778 0x11/imm32/alloc-id:fake +28779 _Primitive-shift-reg-right-signed-by-lit/imm32/next +28780 _Primitive-shift-reg-right-signed-by-lit: # (payload primitive) +28781 0x11/imm32/alloc-id:fake:payload +28782 # var1/reg <- shift-right-signed lit => c1/shift 7/subop/right-preserving-sign var1/rm32 lit/imm32 +28783 0x11/imm32/alloc-id:fake +28784 _string-shift-right-signed/imm32/name 28785 0x11/imm32/alloc-id:fake -28786 _Primitive-min-xreg-with-xreg/imm32/next -28787 # - floating-point minimum -28788 _Primitive-min-xreg-with-xreg: # (payload primitive) -28789 0x11/imm32/alloc-id:fake:payload -28790 # var1/xreg <- divide var2 => f3 0f 5d/min var2/xm32 var1/x32 -28791 0x11/imm32/alloc-id:fake -28792 _string-min/imm32/name -28793 0x11/imm32/alloc-id:fake -28794 Single-float-var-in-some-register/imm32/inouts -28795 0x11/imm32/alloc-id:fake -28796 Single-float-var-in-some-register/imm32/outputs -28797 0x11/imm32/alloc-id:fake -28798 _string_f3_0f_5d_min/imm32/subx-name -28799 0/imm32/no-rm32 -28800 0/imm32/no-r32 -28801 0/imm32/no-imm32 -28802 0/imm32/no-imm8 -28803 0/imm32/no-disp32 -28804 1/imm32/xm32-is-first-inout -28805 3/imm32/x32-is-first-output -28806 0x11/imm32/alloc-id:fake -28807 _Primitive-min-xreg-with-mem/imm32/next -28808 _Primitive-min-xreg-with-mem: # (payload primitive) -28809 0x11/imm32/alloc-id:fake:payload -28810 # var1/xreg <- divide var2 => f3 0f 5d/min var2/xm32 var1/x32 -28811 0x11/imm32/alloc-id:fake -28812 _string-min/imm32/name -28813 0x11/imm32/alloc-id:fake -28814 Single-float-var-in-mem/imm32/inouts -28815 0x11/imm32/alloc-id:fake -28816 Single-float-var-in-some-register/imm32/outputs -28817 0x11/imm32/alloc-id:fake -28818 _string_f3_0f_5d_min/imm32/subx-name -28819 0/imm32/no-rm32 -28820 0/imm32/no-r32 -28821 0/imm32/no-imm32 -28822 0/imm32/no-imm8 -28823 0/imm32/no-disp32 -28824 1/imm32/xm32-is-first-inout -28825 3/imm32/x32-is-first-output -28826 0x11/imm32/alloc-id:fake -28827 _Primitive-reciprocal-xreg-to-xreg/imm32/next -28828 # - floating-point reciprocal -28829 _Primitive-reciprocal-xreg-to-xreg: # (payload primitive) -28830 0x11/imm32/alloc-id:fake:payload -28831 # var1/xreg <- reciprocal var2 => f3 0f 53/reciprocal var2/xm32 var1/x32 -28832 0x11/imm32/alloc-id:fake -28833 _string-reciprocal/imm32/name -28834 0x11/imm32/alloc-id:fake -28835 Single-float-var-in-some-register/imm32/inouts -28836 0x11/imm32/alloc-id:fake -28837 Single-float-var-in-some-register/imm32/outputs +28786 Single-lit-var/imm32/inouts +28787 0x11/imm32/alloc-id:fake +28788 Single-int-var-in-some-register/imm32/outputs +28789 0x11/imm32/alloc-id:fake +28790 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name +28791 3/imm32/rm32-is-first-output +28792 0/imm32/no-r32 +28793 0/imm32/no-imm32 +28794 1/imm32/imm8-is-first-inout +28795 0/imm32/no-disp32 +28796 0/imm32/no-xm32 +28797 0/imm32/no-x32 +28798 0x11/imm32/alloc-id:fake +28799 _Primitive-shift-mem-left-by-lit/imm32/next +28800 _Primitive-shift-mem-left-by-lit: # (payload primitive) +28801 0x11/imm32/alloc-id:fake:payload +28802 # shift-left var1, lit => c1/shift 4/subop/left var1/rm32 lit/imm32 +28803 0x11/imm32/alloc-id:fake +28804 _string-shift-left/imm32/name +28805 0x11/imm32/alloc-id:fake +28806 Int-var-and-literal/imm32/inouts +28807 0/imm32/no-outputs +28808 0/imm32/no-outputs +28809 0x11/imm32/alloc-id:fake +28810 _string_c1_subop_shift_left/imm32/subx-name +28811 1/imm32/rm32-is-first-inout +28812 0/imm32/no-r32 +28813 0/imm32/no-imm32 +28814 2/imm32/imm8-is-second-inout +28815 0/imm32/no-disp32 +28816 0/imm32/no-xm32 +28817 0/imm32/no-x32 +28818 0x11/imm32/alloc-id:fake +28819 _Primitive-shift-mem-right-by-lit/imm32/next +28820 _Primitive-shift-mem-right-by-lit: # (payload primitive) +28821 0x11/imm32/alloc-id:fake:payload +28822 # shift-right var1, lit => c1/shift 5/subop/right var1/rm32 lit/imm32 +28823 0x11/imm32/alloc-id:fake +28824 _string-shift-right/imm32/name +28825 0x11/imm32/alloc-id:fake +28826 Int-var-and-literal/imm32/inouts +28827 0/imm32/no-outputs +28828 0/imm32/no-outputs +28829 0x11/imm32/alloc-id:fake +28830 _string_c1_subop_shift_right_padding_zeroes/imm32/subx-name +28831 1/imm32/rm32-is-first-inout +28832 0/imm32/no-r32 +28833 0/imm32/no-imm32 +28834 2/imm32/imm8-is-second-inout +28835 0/imm32/no-disp32 +28836 0/imm32/no-xm32 +28837 0/imm32/no-x32 28838 0x11/imm32/alloc-id:fake -28839 _string_f3_0f_53_reciprocal/imm32/subx-name -28840 0/imm32/no-rm32 -28841 0/imm32/no-r32 -28842 0/imm32/no-imm32 -28843 0/imm32/no-imm8 -28844 0/imm32/no-disp32 -28845 1/imm32/xm32-is-first-inout -28846 3/imm32/x32-is-first-output -28847 0x11/imm32/alloc-id:fake -28848 _Primitive-reciprocal-mem-to-xreg/imm32/next -28849 _Primitive-reciprocal-mem-to-xreg: # (payload primitive) -28850 0x11/imm32/alloc-id:fake:payload -28851 # var1/xreg <- divide var2 => f3 0f 53/reciprocal var2/xm32 var1/x32 -28852 0x11/imm32/alloc-id:fake -28853 _string-reciprocal/imm32/name -28854 0x11/imm32/alloc-id:fake -28855 Single-float-var-in-mem/imm32/inouts -28856 0x11/imm32/alloc-id:fake -28857 Single-float-var-in-some-register/imm32/outputs +28839 _Primitive-shift-mem-right-signed-by-lit/imm32/next +28840 _Primitive-shift-mem-right-signed-by-lit: # (payload primitive) +28841 0x11/imm32/alloc-id:fake:payload +28842 # shift-right-signed var1, lit => c1/shift 7/subop/right-preserving-sign var1/rm32 lit/imm32 +28843 0x11/imm32/alloc-id:fake +28844 _string-shift-right-signed/imm32/name +28845 0x11/imm32/alloc-id:fake +28846 Int-var-and-literal/imm32/inouts +28847 0/imm32/no-outputs +28848 0/imm32/no-outputs +28849 0x11/imm32/alloc-id:fake +28850 _string_c1_subop_shift_right_preserving_sign/imm32/subx-name +28851 1/imm32/rm32-is-first-inout +28852 0/imm32/no-r32 +28853 0/imm32/no-imm32 +28854 2/imm32/imm8-is-second-inout +28855 0/imm32/no-disp32 +28856 0/imm32/no-xm32 +28857 0/imm32/no-x32 28858 0x11/imm32/alloc-id:fake -28859 _string_f3_0f_53_reciprocal/imm32/subx-name -28860 0/imm32/no-rm32 -28861 0/imm32/no-r32 -28862 0/imm32/no-imm32 -28863 0/imm32/no-imm8 -28864 0/imm32/no-disp32 -28865 1/imm32/xm32-is-first-inout -28866 3/imm32/x32-is-first-output -28867 0x11/imm32/alloc-id:fake -28868 _Primitive-square-root-xreg-to-xreg/imm32/next -28869 # - floating-point square root -28870 _Primitive-square-root-xreg-to-xreg: # (payload primitive) -28871 0x11/imm32/alloc-id:fake:payload -28872 # var1/xreg <- square-root var2 => f3 0f 51/square-root var2/xm32 var1/x32 -28873 0x11/imm32/alloc-id:fake -28874 _string-square-root/imm32/name -28875 0x11/imm32/alloc-id:fake -28876 Single-float-var-in-some-register/imm32/inouts -28877 0x11/imm32/alloc-id:fake -28878 Single-float-var-in-some-register/imm32/outputs +28859 _Primitive-copy-to-eax/imm32/next +28860 # - copy +28861 _Primitive-copy-to-eax: # (payload primitive) +28862 0x11/imm32/alloc-id:fake:payload +28863 # var/eax <- copy lit => b8/copy-to-eax lit/imm32 +28864 0x11/imm32/alloc-id:fake +28865 _string-copy/imm32/name +28866 0x11/imm32/alloc-id:fake +28867 Single-lit-var/imm32/inouts +28868 0x11/imm32/alloc-id:fake +28869 Single-int-var-in-eax/imm32/outputs +28870 0x11/imm32/alloc-id:fake +28871 _string_b8_copy_to_eax/imm32/subx-name +28872 0/imm32/no-rm32 +28873 0/imm32/no-r32 +28874 1/imm32/imm32-is-first-inout +28875 0/imm32/no-imm8 +28876 0/imm32/no-disp32 +28877 0/imm32/no-xm32 +28878 0/imm32/no-x32 28879 0x11/imm32/alloc-id:fake -28880 _string_f3_0f_51_square_root/imm32/subx-name -28881 0/imm32/no-rm32 -28882 0/imm32/no-r32 -28883 0/imm32/no-imm32 -28884 0/imm32/no-imm8 -28885 0/imm32/no-disp32 -28886 1/imm32/xm32-is-first-inout -28887 3/imm32/x32-is-first-output +28880 _Primitive-copy-to-ecx/imm32/next +28881 _Primitive-copy-to-ecx: # (payload primitive) +28882 0x11/imm32/alloc-id:fake:payload +28883 # var/ecx <- copy lit => b9/copy-to-ecx lit/imm32 +28884 0x11/imm32/alloc-id:fake +28885 _string-copy/imm32/name +28886 0x11/imm32/alloc-id:fake +28887 Single-lit-var/imm32/inouts 28888 0x11/imm32/alloc-id:fake -28889 _Primitive-square-root-mem-to-xreg/imm32/next -28890 _Primitive-square-root-mem-to-xreg: # (payload primitive) -28891 0x11/imm32/alloc-id:fake:payload -28892 # var1/xreg <- divide var2 => f3 0f 51/square-root var2/xm32 var1/x32 -28893 0x11/imm32/alloc-id:fake -28894 _string-square-root/imm32/name -28895 0x11/imm32/alloc-id:fake -28896 Single-float-var-in-mem/imm32/inouts -28897 0x11/imm32/alloc-id:fake -28898 Single-float-var-in-some-register/imm32/outputs +28889 Single-int-var-in-ecx/imm32/outputs +28890 0x11/imm32/alloc-id:fake +28891 _string_b9_copy_to_ecx/imm32/subx-name +28892 0/imm32/no-rm32 +28893 0/imm32/no-r32 +28894 1/imm32/imm32-is-first-inout +28895 0/imm32/no-imm8 +28896 0/imm32/no-disp32 +28897 0/imm32/no-xm32 +28898 0/imm32/no-x32 28899 0x11/imm32/alloc-id:fake -28900 _string_f3_0f_51_square_root/imm32/subx-name -28901 0/imm32/no-rm32 -28902 0/imm32/no-r32 -28903 0/imm32/no-imm32 -28904 0/imm32/no-imm8 -28905 0/imm32/no-disp32 -28906 1/imm32/xm32-is-first-inout -28907 3/imm32/x32-is-first-output +28900 _Primitive-copy-to-edx/imm32/next +28901 _Primitive-copy-to-edx: # (payload primitive) +28902 0x11/imm32/alloc-id:fake:payload +28903 # var/edx <- copy lit => ba/copy-to-edx lit/imm32 +28904 0x11/imm32/alloc-id:fake +28905 _string-copy/imm32/name +28906 0x11/imm32/alloc-id:fake +28907 Single-lit-var/imm32/inouts 28908 0x11/imm32/alloc-id:fake -28909 _Primitive-inverse-square-root-xreg-to-xreg/imm32/next -28910 # - floating-point inverse square root 1/sqrt(x) -28911 _Primitive-inverse-square-root-xreg-to-xreg: # (payload primitive) -28912 0x11/imm32/alloc-id:fake:payload -28913 # var1/xreg <- reciprocal var2 => f3 0f 52/inverse-square-root var2/xm32 var1/x32 -28914 0x11/imm32/alloc-id:fake -28915 _string-inverse-square-root/imm32/name -28916 0x11/imm32/alloc-id:fake -28917 Single-float-var-in-some-register/imm32/inouts -28918 0x11/imm32/alloc-id:fake -28919 Single-float-var-in-some-register/imm32/outputs -28920 0x11/imm32/alloc-id:fake -28921 _string_f3_0f_52_inverse_square_root/imm32/subx-name -28922 0/imm32/no-rm32 -28923 0/imm32/no-r32 -28924 0/imm32/no-imm32 -28925 0/imm32/no-imm8 -28926 0/imm32/no-disp32 -28927 1/imm32/xm32-is-first-inout -28928 3/imm32/x32-is-first-output -28929 0x11/imm32/alloc-id:fake -28930 _Primitive-inverse-square-root-mem-to-xreg/imm32/next -28931 _Primitive-inverse-square-root-mem-to-xreg: # (payload primitive) -28932 0x11/imm32/alloc-id:fake:payload -28933 # var1/xreg <- divide var2 => f3 0f 52/inverse-square-root var2/xm32 var1/x32 -28934 0x11/imm32/alloc-id:fake -28935 _string-inverse-square-root/imm32/name -28936 0x11/imm32/alloc-id:fake -28937 Single-float-var-in-mem/imm32/inouts -28938 0x11/imm32/alloc-id:fake -28939 Single-float-var-in-some-register/imm32/outputs -28940 0x11/imm32/alloc-id:fake -28941 _string_f3_0f_52_inverse_square_root/imm32/subx-name -28942 0/imm32/no-rm32 -28943 0/imm32/no-r32 -28944 0/imm32/no-imm32 -28945 0/imm32/no-imm8 -28946 0/imm32/no-disp32 -28947 1/imm32/xm32-is-first-inout -28948 3/imm32/x32-is-first-output -28949 0x11/imm32/alloc-id:fake -28950 _Primitive-compare-xreg-with-xreg/imm32/next -28951 # - floating-point compare -28952 _Primitive-compare-xreg-with-xreg: # (payload primitive) -28953 0x11/imm32/alloc-id:fake:payload -28954 # compare var1/reg1 var2/reg2 => 0f 2f/compare var2/x32 var1/xm32 -28955 0x11/imm32/alloc-id:fake -28956 _string-compare/imm32/name -28957 0x11/imm32/alloc-id:fake -28958 Two-float-args-in-regs/imm32/inouts -28959 0/imm32/no-outputs -28960 0/imm32/no-outputs -28961 0x11/imm32/alloc-id:fake -28962 _string_0f_2f_compare/imm32/subx-name -28963 0/imm32/no-rm32 -28964 0/imm32/no-r32 -28965 0/imm32/no-imm32 -28966 0/imm32/no-imm8 -28967 0/imm32/no-disp32 -28968 1/imm32/xm32-is-first-inout -28969 2/imm32/x32-is-second-inout +28909 Single-int-var-in-edx/imm32/outputs +28910 0x11/imm32/alloc-id:fake +28911 _string_ba_copy_to_edx/imm32/subx-name +28912 0/imm32/no-rm32 +28913 0/imm32/no-r32 +28914 1/imm32/imm32-is-first-inout +28915 0/imm32/no-imm8 +28916 0/imm32/no-disp32 +28917 0/imm32/no-xm32 +28918 0/imm32/no-x32 +28919 0x11/imm32/alloc-id:fake +28920 _Primitive-copy-to-ebx/imm32/next +28921 _Primitive-copy-to-ebx: # (payload primitive) +28922 0x11/imm32/alloc-id:fake:payload +28923 # var/ebx <- copy lit => bb/copy-to-ebx lit/imm32 +28924 0x11/imm32/alloc-id:fake +28925 _string-copy/imm32/name +28926 0x11/imm32/alloc-id:fake +28927 Single-lit-var/imm32/inouts +28928 0x11/imm32/alloc-id:fake +28929 Single-int-var-in-ebx/imm32/outputs +28930 0x11/imm32/alloc-id:fake +28931 _string_bb_copy_to_ebx/imm32/subx-name +28932 0/imm32/no-rm32 +28933 0/imm32/no-r32 +28934 1/imm32/imm32-is-first-inout +28935 0/imm32/no-imm8 +28936 0/imm32/no-disp32 +28937 0/imm32/no-xm32 +28938 0/imm32/no-x32 +28939 0x11/imm32/alloc-id:fake +28940 _Primitive-copy-to-esi/imm32/next +28941 _Primitive-copy-to-esi: # (payload primitive) +28942 0x11/imm32/alloc-id:fake:payload +28943 # var/esi <- copy lit => be/copy-to-esi lit/imm32 +28944 0x11/imm32/alloc-id:fake +28945 _string-copy/imm32/name +28946 0x11/imm32/alloc-id:fake +28947 Single-lit-var/imm32/inouts +28948 0x11/imm32/alloc-id:fake +28949 Single-int-var-in-esi/imm32/outputs +28950 0x11/imm32/alloc-id:fake +28951 _string_be_copy_to_esi/imm32/subx-name +28952 0/imm32/no-rm32 +28953 0/imm32/no-r32 +28954 1/imm32/imm32-is-first-inout +28955 0/imm32/no-imm8 +28956 0/imm32/no-disp32 +28957 0/imm32/no-xm32 +28958 0/imm32/no-x32 +28959 0x11/imm32/alloc-id:fake +28960 _Primitive-copy-to-edi/imm32/next +28961 _Primitive-copy-to-edi: # (payload primitive) +28962 0x11/imm32/alloc-id:fake:payload +28963 # var/edi <- copy lit => bf/copy-to-edi lit/imm32 +28964 0x11/imm32/alloc-id:fake +28965 _string-copy/imm32/name +28966 0x11/imm32/alloc-id:fake +28967 Single-lit-var/imm32/inouts +28968 0x11/imm32/alloc-id:fake +28969 Single-int-var-in-edi/imm32/outputs 28970 0x11/imm32/alloc-id:fake -28971 _Primitive-compare-xreg-with-mem/imm32/next -28972 _Primitive-compare-xreg-with-mem: # (payload primitive) -28973 0x11/imm32/alloc-id:fake:payload -28974 # compare var1/xreg var2 => 0f 2f/compare var1/x32 var2/xm32 -28975 0x11/imm32/alloc-id:fake -28976 _string-compare/imm32/name -28977 0x11/imm32/alloc-id:fake -28978 Two-args-float-reg-float-stack/imm32/inouts -28979 0/imm32/no-outputs -28980 0/imm32/no-outputs -28981 0x11/imm32/alloc-id:fake -28982 _string_0f_2f_compare/imm32/subx-name -28983 0/imm32/no-rm32 -28984 0/imm32/no-r32 -28985 0/imm32/no-imm32 -28986 0/imm32/no-imm8 -28987 0/imm32/no-disp32 -28988 2/imm32/xm32-is-second-inout -28989 1/imm32/x32-is-first-inout +28971 _string_bf_copy_to_edi/imm32/subx-name +28972 0/imm32/no-rm32 +28973 0/imm32/no-r32 +28974 1/imm32/imm32-is-first-inout +28975 0/imm32/no-imm8 +28976 0/imm32/no-disp32 +28977 0/imm32/no-xm32 +28978 0/imm32/no-x32 +28979 0x11/imm32/alloc-id:fake +28980 _Primitive-copy-reg-to-reg/imm32/next +28981 _Primitive-copy-reg-to-reg: # (payload primitive) +28982 0x11/imm32/alloc-id:fake:payload +28983 # var1/reg <- copy var2/reg => 89/<- var1/rm32 var2/r32 +28984 0x11/imm32/alloc-id:fake +28985 _string-copy/imm32/name +28986 0x11/imm32/alloc-id:fake +28987 Single-int-var-in-some-register/imm32/inouts +28988 0x11/imm32/alloc-id:fake +28989 Single-int-var-in-some-register/imm32/outputs 28990 0x11/imm32/alloc-id:fake -28991 _Primitive-break-if-addr</imm32/next -28992 # - branches -28993 _Primitive-break-if-addr<: # (payload primitive) -28994 0x11/imm32/alloc-id:fake:payload -28995 0x11/imm32/alloc-id:fake -28996 _string-break-if-addr</imm32/name -28997 0/imm32/no-inouts -28998 0/imm32/no-inouts -28999 0/imm32/no-outputs -29000 0/imm32/no-outputs -29001 0x11/imm32/alloc-id:fake -29002 _string_0f_82_jump_break/imm32/subx-name -29003 0/imm32/no-rm32 -29004 0/imm32/no-r32 -29005 0/imm32/no-imm32 -29006 0/imm32/no-imm8 -29007 0/imm32/no-disp32 -29008 0/imm32/no-xm32 -29009 0/imm32/no-x32 +28991 _string_89_<-/imm32/subx-name +28992 3/imm32/rm32-is-first-output +28993 1/imm32/r32-is-first-inout +28994 0/imm32/no-imm32 +28995 0/imm32/no-imm8 +28996 0/imm32/no-disp32 +28997 0/imm32/no-xm32 +28998 0/imm32/no-x32 +28999 0x11/imm32/alloc-id:fake +29000 _Primitive-copy-reg-to-mem/imm32/next +29001 _Primitive-copy-reg-to-mem: # (payload primitive) +29002 0x11/imm32/alloc-id:fake:payload +29003 # copy-to var1 var2/reg => 89/<- var1 var2/r32 +29004 0x11/imm32/alloc-id:fake +29005 _string-copy-to/imm32/name +29006 0x11/imm32/alloc-id:fake +29007 Two-args-int-stack-int-reg/imm32/inouts +29008 0/imm32/no-outputs +29009 0/imm32/no-outputs 29010 0x11/imm32/alloc-id:fake -29011 _Primitive-break-if-addr>=/imm32/next -29012 _Primitive-break-if-addr>=: # (payload primitive) -29013 0x11/imm32/alloc-id:fake:payload -29014 0x11/imm32/alloc-id:fake -29015 _string-break-if-addr>=/imm32/name -29016 0/imm32/no-inouts -29017 0/imm32/no-inouts -29018 0/imm32/no-outputs -29019 0/imm32/no-outputs -29020 0x11/imm32/alloc-id:fake -29021 _string_0f_83_jump_break/imm32/subx-name -29022 0/imm32/no-rm32 -29023 0/imm32/no-r32 -29024 0/imm32/no-imm32 -29025 0/imm32/no-imm8 -29026 0/imm32/no-disp32 -29027 0/imm32/no-xm32 -29028 0/imm32/no-x32 -29029 0x11/imm32/alloc-id:fake -29030 _Primitive-break-if-=/imm32/next -29031 _Primitive-break-if-=: # (payload primitive) -29032 0x11/imm32/alloc-id:fake:payload -29033 0x11/imm32/alloc-id:fake -29034 _string-break-if-=/imm32/name -29035 0/imm32/no-inouts -29036 0/imm32/no-inouts -29037 0/imm32/no-outputs -29038 0/imm32/no-outputs +29011 _string_89_<-/imm32/subx-name +29012 1/imm32/rm32-is-first-inout +29013 2/imm32/r32-is-second-inout +29014 0/imm32/no-imm32 +29015 0/imm32/no-imm8 +29016 0/imm32/no-disp32 +29017 0/imm32/no-xm32 +29018 0/imm32/no-x32 +29019 0x11/imm32/alloc-id:fake +29020 _Primitive-copy-mem-to-reg/imm32/next +29021 _Primitive-copy-mem-to-reg: # (payload primitive) +29022 0x11/imm32/alloc-id:fake:payload +29023 # var1/reg <- copy var2 => 8b/-> var2/rm32 var1/r32 +29024 0x11/imm32/alloc-id:fake +29025 _string-copy/imm32/name +29026 0x11/imm32/alloc-id:fake +29027 Single-int-var-in-mem/imm32/inouts +29028 0x11/imm32/alloc-id:fake +29029 Single-int-var-in-some-register/imm32/outputs +29030 0x11/imm32/alloc-id:fake +29031 _string_8b_->/imm32/subx-name +29032 1/imm32/rm32-is-first-inout +29033 3/imm32/r32-is-first-output +29034 0/imm32/no-imm32 +29035 0/imm32/no-imm8 +29036 0/imm32/no-disp32 +29037 0/imm32/no-xm32 +29038 0/imm32/no-x32 29039 0x11/imm32/alloc-id:fake -29040 _string_0f_84_jump_break/imm32/subx-name -29041 0/imm32/no-rm32 -29042 0/imm32/no-r32 -29043 0/imm32/no-imm32 -29044 0/imm32/no-imm8 -29045 0/imm32/no-disp32 -29046 0/imm32/no-xm32 -29047 0/imm32/no-x32 +29040 _Primitive-copy-lit-to-reg/imm32/next +29041 _Primitive-copy-lit-to-reg: # (payload primitive) +29042 0x11/imm32/alloc-id:fake:payload +29043 # var1/reg <- copy lit => c7 0/subop/copy var1/rm32 lit/imm32 +29044 0x11/imm32/alloc-id:fake +29045 _string-copy/imm32/name +29046 0x11/imm32/alloc-id:fake +29047 Single-lit-var/imm32/inouts 29048 0x11/imm32/alloc-id:fake -29049 _Primitive-break-if-!=/imm32/next -29050 _Primitive-break-if-!=: # (payload primitive) -29051 0x11/imm32/alloc-id:fake:payload -29052 0x11/imm32/alloc-id:fake -29053 _string-break-if-!=/imm32/name -29054 0/imm32/no-inouts -29055 0/imm32/no-inouts -29056 0/imm32/no-outputs -29057 0/imm32/no-outputs -29058 0x11/imm32/alloc-id:fake -29059 _string_0f_85_jump_break/imm32/subx-name -29060 0/imm32/no-rm32 -29061 0/imm32/no-r32 -29062 0/imm32/no-imm32 -29063 0/imm32/no-imm8 -29064 0/imm32/no-disp32 -29065 0/imm32/no-xm32 -29066 0/imm32/no-x32 -29067 0x11/imm32/alloc-id:fake -29068 _Primitive-break-if-addr<=/imm32/next -29069 _Primitive-break-if-addr<=: # (payload primitive) -29070 0x11/imm32/alloc-id:fake:payload -29071 0x11/imm32/alloc-id:fake -29072 _string-break-if-addr<=/imm32/name -29073 0/imm32/no-inouts -29074 0/imm32/no-inouts -29075 0/imm32/no-outputs -29076 0/imm32/no-outputs -29077 0x11/imm32/alloc-id:fake -29078 _string_0f_86_jump_break/imm32/subx-name -29079 0/imm32/no-rm32 -29080 0/imm32/no-r32 -29081 0/imm32/no-imm32 -29082 0/imm32/no-imm8 -29083 0/imm32/no-disp32 -29084 0/imm32/no-xm32 -29085 0/imm32/no-x32 -29086 0x11/imm32/alloc-id:fake -29087 _Primitive-break-if-addr>/imm32/next -29088 _Primitive-break-if-addr>: # (payload primitive) -29089 0x11/imm32/alloc-id:fake:payload -29090 0x11/imm32/alloc-id:fake -29091 _string-break-if-addr>/imm32/name -29092 0/imm32/no-inouts -29093 0/imm32/no-inouts -29094 0/imm32/no-outputs -29095 0/imm32/no-outputs -29096 0x11/imm32/alloc-id:fake -29097 _string_0f_87_jump_break/imm32/subx-name -29098 0/imm32/no-rm32 -29099 0/imm32/no-r32 -29100 0/imm32/no-imm32 -29101 0/imm32/no-imm8 -29102 0/imm32/no-disp32 -29103 0/imm32/no-xm32 -29104 0/imm32/no-x32 +29049 Single-int-var-in-some-register/imm32/outputs +29050 0x11/imm32/alloc-id:fake +29051 _string_c7_subop_copy/imm32/subx-name +29052 3/imm32/rm32-is-first-output +29053 0/imm32/no-r32 +29054 1/imm32/imm32-is-first-inout +29055 0/imm32/no-imm8 +29056 0/imm32/no-disp32 +29057 0/imm32/no-xm32 +29058 0/imm32/no-x32 +29059 0x11/imm32/alloc-id:fake +29060 _Primitive-copy-lit-to-mem/imm32/next +29061 _Primitive-copy-lit-to-mem: # (payload primitive) +29062 0x11/imm32/alloc-id:fake:payload +29063 # copy-to var1, lit => c7 0/subop/copy var1/rm32 lit/imm32 +29064 0x11/imm32/alloc-id:fake +29065 _string-copy-to/imm32/name +29066 0x11/imm32/alloc-id:fake +29067 Int-var-and-literal/imm32/inouts +29068 0/imm32/no-outputs +29069 0/imm32/no-outputs +29070 0x11/imm32/alloc-id:fake +29071 _string_c7_subop_copy/imm32/subx-name +29072 1/imm32/rm32-is-first-inout +29073 0/imm32/no-r32 +29074 2/imm32/imm32-is-second-inout +29075 0/imm32/no-imm8 +29076 0/imm32/no-disp32 +29077 0/imm32/no-xm32 +29078 0/imm32/no-x32 +29079 0x11/imm32/alloc-id:fake +29080 _Primitive-copy-byte-from-reg/imm32/next +29081 # - copy byte +29082 _Primitive-copy-byte-from-reg: +29083 0x11/imm32/alloc-id:fake:payload +29084 # var/reg <- copy-byte var2/reg2 => 8a/byte-> %var2 var/r32 +29085 0x11/imm32/alloc-id:fake +29086 _string-copy-byte/imm32/name +29087 0x11/imm32/alloc-id:fake +29088 Single-byte-var-in-some-register/imm32/inouts +29089 0x11/imm32/alloc-id:fake +29090 Single-byte-var-in-some-register/imm32/outputs +29091 0x11/imm32/alloc-id:fake +29092 _string_8a_copy_byte/imm32/subx-name +29093 1/imm32/rm32-is-first-inout +29094 3/imm32/r32-is-first-output +29095 0/imm32/no-imm32 +29096 0/imm32/no-imm8 +29097 0/imm32/no-disp32 +29098 0/imm32/no-xm32 +29099 0/imm32/no-x32 +29100 0x11/imm32/alloc-id:fake +29101 _Primitive-copy-byte-from-mem/imm32/next +29102 _Primitive-copy-byte-from-mem: +29103 0x11/imm32/alloc-id:fake:payload +29104 # var/reg <- copy-byte *var2/reg2 => 8a/byte-> *var2 var/r32 29105 0x11/imm32/alloc-id:fake -29106 _Primitive-break-if-</imm32/next -29107 _Primitive-break-if-<: # (payload primitive) -29108 0x11/imm32/alloc-id:fake:payload +29106 _string-copy-byte/imm32/name +29107 0x11/imm32/alloc-id:fake +29108 Single-byte-var-in-mem/imm32/inouts 29109 0x11/imm32/alloc-id:fake -29110 _string-break-if-</imm32/name -29111 0/imm32/no-inouts -29112 0/imm32/no-inouts -29113 0/imm32/no-outputs -29114 0/imm32/no-outputs -29115 0x11/imm32/alloc-id:fake -29116 _string_0f_8c_jump_break/imm32/subx-name -29117 0/imm32/no-rm32 -29118 0/imm32/no-r32 -29119 0/imm32/no-imm32 -29120 0/imm32/no-imm8 -29121 0/imm32/no-disp32 -29122 0/imm32/no-xm32 -29123 0/imm32/no-x32 -29124 0x11/imm32/alloc-id:fake -29125 _Primitive-break-if->=/imm32/next -29126 _Primitive-break-if->=: # (payload primitive) -29127 0x11/imm32/alloc-id:fake:payload -29128 0x11/imm32/alloc-id:fake -29129 _string-break-if->=/imm32/name -29130 0/imm32/no-inouts -29131 0/imm32/no-inouts -29132 0/imm32/no-outputs -29133 0/imm32/no-outputs -29134 0x11/imm32/alloc-id:fake -29135 _string_0f_8d_jump_break/imm32/subx-name -29136 0/imm32/no-rm32 -29137 0/imm32/no-r32 -29138 0/imm32/no-imm32 -29139 0/imm32/no-imm8 -29140 0/imm32/no-disp32 -29141 0/imm32/no-xm32 -29142 0/imm32/no-x32 -29143 0x11/imm32/alloc-id:fake -29144 _Primitive-break-if-<=/imm32/next -29145 _Primitive-break-if-<=: # (payload primitive) -29146 0x11/imm32/alloc-id:fake:payload -29147 0x11/imm32/alloc-id:fake -29148 _string-break-if-<=/imm32/name -29149 0/imm32/no-inouts -29150 0/imm32/no-inouts -29151 0/imm32/no-outputs -29152 0/imm32/no-outputs -29153 0x11/imm32/alloc-id:fake -29154 _string_0f_8e_jump_break/imm32/subx-name -29155 0/imm32/no-rm32 -29156 0/imm32/no-r32 -29157 0/imm32/no-imm32 -29158 0/imm32/no-imm8 -29159 0/imm32/no-disp32 -29160 0/imm32/no-xm32 -29161 0/imm32/no-x32 -29162 0x11/imm32/alloc-id:fake -29163 _Primitive-break-if->/imm32/next -29164 _Primitive-break-if->: # (payload primitive) +29110 Single-byte-var-in-some-register/imm32/outputs +29111 0x11/imm32/alloc-id:fake +29112 _string_8a_copy_byte/imm32/subx-name +29113 1/imm32/rm32-is-first-inout +29114 3/imm32/r32-is-first-output +29115 0/imm32/no-imm32 +29116 0/imm32/no-imm8 +29117 0/imm32/no-disp32 +29118 0/imm32/no-xm32 +29119 0/imm32/no-x32 +29120 0x11/imm32/alloc-id:fake +29121 _Primitive-copy-byte-to-mem/imm32/next +29122 _Primitive-copy-byte-to-mem: +29123 0x11/imm32/alloc-id:fake:payload +29124 # copy-byte-to *var1/reg1, var2/reg2 => 88/byte<- *reg1 reg2/r32 +29125 0x11/imm32/alloc-id:fake +29126 _string-copy-byte-to/imm32/name +29127 0x11/imm32/alloc-id:fake +29128 Two-args-byte-stack-byte-reg/imm32/inouts +29129 0/imm32/no-outputs +29130 0/imm32/no-outputs +29131 0x11/imm32/alloc-id:fake +29132 _string_88_copy_byte/imm32/subx-name +29133 1/imm32/rm32-is-first-inout +29134 2/imm32/r32-is-second-inout +29135 0/imm32/no-imm32 +29136 0/imm32/no-imm8 +29137 0/imm32/no-disp32 +29138 0/imm32/no-xm32 +29139 0/imm32/no-x32 +29140 0x11/imm32/alloc-id:fake +29141 _Primitive-address/imm32/next +29142 # - address +29143 _Primitive-address: # (payload primitive) +29144 0x11/imm32/alloc-id:fake:payload +29145 # var1/reg <- address var2 => 8d/copy-address var2/rm32 var1/r32 +29146 0x11/imm32/alloc-id:fake +29147 _string-address/imm32/name +29148 0x11/imm32/alloc-id:fake +29149 Single-int-var-in-mem/imm32/inouts +29150 0x11/imm32/alloc-id:fake +29151 Single-addr-var-in-some-register/imm32/outputs +29152 0x11/imm32/alloc-id:fake +29153 _string_8d_copy_address/imm32/subx-name +29154 1/imm32/rm32-is-first-inout +29155 3/imm32/r32-is-first-output +29156 0/imm32/no-imm32 +29157 0/imm32/no-imm8 +29158 0/imm32/no-disp32 +29159 0/imm32/no-xm32 +29160 0/imm32/no-x32 +29161 0x11/imm32/alloc-id:fake +29162 _Primitive-compare-reg-with-reg/imm32/next +29163 # - compare +29164 _Primitive-compare-reg-with-reg: # (payload primitive) 29165 0x11/imm32/alloc-id:fake:payload -29166 0x11/imm32/alloc-id:fake -29167 _string-break-if->/imm32/name -29168 0/imm32/no-inouts -29169 0/imm32/no-inouts -29170 0/imm32/no-outputs +29166 # compare var1/reg1 var2/reg2 => 39/compare var1/rm32 var2/r32 +29167 0x11/imm32/alloc-id:fake +29168 _string-compare/imm32/name +29169 0x11/imm32/alloc-id:fake +29170 Two-int-args-in-regs/imm32/inouts 29171 0/imm32/no-outputs -29172 0x11/imm32/alloc-id:fake -29173 _string_0f_8f_jump_break/imm32/subx-name -29174 0/imm32/no-rm32 -29175 0/imm32/no-r32 -29176 0/imm32/no-imm32 -29177 0/imm32/no-imm8 -29178 0/imm32/no-disp32 -29179 0/imm32/no-xm32 -29180 0/imm32/no-x32 -29181 0x11/imm32/alloc-id:fake -29182 _Primitive-break/imm32/next -29183 _Primitive-break: # (payload primitive) -29184 0x11/imm32/alloc-id:fake:payload -29185 0x11/imm32/alloc-id:fake -29186 _string-break/imm32/name -29187 0/imm32/no-inouts -29188 0/imm32/no-inouts -29189 0/imm32/no-outputs -29190 0/imm32/no-outputs -29191 0x11/imm32/alloc-id:fake -29192 _string_e9_jump_break/imm32/subx-name -29193 0/imm32/no-rm32 -29194 0/imm32/no-r32 -29195 0/imm32/no-imm32 -29196 0/imm32/no-imm8 -29197 0/imm32/no-disp32 -29198 0/imm32/no-xm32 -29199 0/imm32/no-x32 -29200 0x11/imm32/alloc-id:fake -29201 _Primitive-loop-if-addr</imm32/next -29202 _Primitive-loop-if-addr<: # (payload primitive) -29203 0x11/imm32/alloc-id:fake:payload -29204 0x11/imm32/alloc-id:fake -29205 _string-loop-if-addr</imm32/name -29206 0/imm32/no-inouts -29207 0/imm32/no-inouts -29208 0/imm32/no-outputs -29209 0/imm32/no-outputs -29210 0x11/imm32/alloc-id:fake -29211 _string_0f_82_jump_loop/imm32/subx-name -29212 0/imm32/no-rm32 -29213 0/imm32/no-r32 -29214 0/imm32/no-imm32 -29215 0/imm32/no-imm8 -29216 0/imm32/no-disp32 -29217 0/imm32/no-xm32 -29218 0/imm32/no-x32 -29219 0x11/imm32/alloc-id:fake -29220 _Primitive-loop-if-addr>=/imm32/next -29221 _Primitive-loop-if-addr>=: # (payload primitive) -29222 0x11/imm32/alloc-id:fake:payload -29223 0x11/imm32/alloc-id:fake -29224 _string-loop-if-addr>=/imm32/name -29225 0/imm32/no-inouts -29226 0/imm32/no-inouts -29227 0/imm32/no-outputs -29228 0/imm32/no-outputs +29172 0/imm32/no-outputs +29173 0x11/imm32/alloc-id:fake +29174 _string_39_compare->/imm32/subx-name +29175 1/imm32/rm32-is-first-inout +29176 2/imm32/r32-is-second-inout +29177 0/imm32/no-imm32 +29178 0/imm32/no-imm8 +29179 0/imm32/no-disp32 +29180 0/imm32/no-xm32 +29181 0/imm32/no-x32 +29182 0x11/imm32/alloc-id:fake +29183 _Primitive-compare-mem-with-reg/imm32/next +29184 _Primitive-compare-mem-with-reg: # (payload primitive) +29185 0x11/imm32/alloc-id:fake:payload +29186 # compare var1 var2/reg => 39/compare var1/rm32 var2/r32 +29187 0x11/imm32/alloc-id:fake +29188 _string-compare/imm32/name +29189 0x11/imm32/alloc-id:fake +29190 Two-args-int-stack-int-reg/imm32/inouts +29191 0/imm32/no-outputs +29192 0/imm32/no-outputs +29193 0x11/imm32/alloc-id:fake +29194 _string_39_compare->/imm32/subx-name +29195 1/imm32/rm32-is-first-inout +29196 2/imm32/r32-is-second-inout +29197 0/imm32/no-imm32 +29198 0/imm32/no-imm8 +29199 0/imm32/no-disp32 +29200 0/imm32/no-xm32 +29201 0/imm32/no-x32 +29202 0x11/imm32/alloc-id:fake +29203 _Primitive-compare-reg-with-mem/imm32/next +29204 _Primitive-compare-reg-with-mem: # (payload primitive) +29205 0x11/imm32/alloc-id:fake:payload +29206 # compare var1/reg var2 => 3b/compare<- var2/rm32 var1/r32 +29207 0x11/imm32/alloc-id:fake +29208 _string-compare/imm32/name +29209 0x11/imm32/alloc-id:fake +29210 Two-args-int-reg-int-stack/imm32/inouts +29211 0/imm32/no-outputs +29212 0/imm32/no-outputs +29213 0x11/imm32/alloc-id:fake +29214 _string_3b_compare<-/imm32/subx-name +29215 2/imm32/rm32-is-second-inout +29216 1/imm32/r32-is-first-inout +29217 0/imm32/no-imm32 +29218 0/imm32/no-imm8 +29219 0/imm32/no-disp32 +29220 0/imm32/no-xm32 +29221 0/imm32/no-x32 +29222 0x11/imm32/alloc-id:fake +29223 _Primitive-compare-eax-with-literal/imm32/next +29224 _Primitive-compare-eax-with-literal: # (payload primitive) +29225 0x11/imm32/alloc-id:fake:payload +29226 # compare var1/eax n => 3d/compare-eax-with n/imm32 +29227 0x11/imm32/alloc-id:fake +29228 _string-compare/imm32/name 29229 0x11/imm32/alloc-id:fake -29230 _string_0f_83_jump_loop/imm32/subx-name -29231 0/imm32/no-rm32 -29232 0/imm32/no-r32 -29233 0/imm32/no-imm32 -29234 0/imm32/no-imm8 -29235 0/imm32/no-disp32 -29236 0/imm32/no-xm32 -29237 0/imm32/no-x32 -29238 0x11/imm32/alloc-id:fake -29239 _Primitive-loop-if-=/imm32/next -29240 _Primitive-loop-if-=: # (payload primitive) -29241 0x11/imm32/alloc-id:fake:payload +29230 Two-args-int-eax-int-literal/imm32/inouts +29231 0/imm32/no-outputs +29232 0/imm32/no-outputs +29233 0x11/imm32/alloc-id:fake +29234 _string_3d_compare_eax_with/imm32/subx-name +29235 0/imm32/no-rm32 +29236 0/imm32/no-r32 +29237 2/imm32/imm32-is-second-inout +29238 0/imm32/no-imm8 +29239 0/imm32/no-disp32 +29240 0/imm32/no-xm32 +29241 0/imm32/no-x32 29242 0x11/imm32/alloc-id:fake -29243 _string-loop-if-=/imm32/name -29244 0/imm32/no-inouts -29245 0/imm32/no-inouts -29246 0/imm32/no-outputs -29247 0/imm32/no-outputs -29248 0x11/imm32/alloc-id:fake -29249 _string_0f_84_jump_loop/imm32/subx-name -29250 0/imm32/no-rm32 -29251 0/imm32/no-r32 -29252 0/imm32/no-imm32 -29253 0/imm32/no-imm8 -29254 0/imm32/no-disp32 -29255 0/imm32/no-xm32 -29256 0/imm32/no-x32 -29257 0x11/imm32/alloc-id:fake -29258 _Primitive-loop-if-!=/imm32/next -29259 _Primitive-loop-if-!=: # (payload primitive) -29260 0x11/imm32/alloc-id:fake:payload -29261 0x11/imm32/alloc-id:fake -29262 _string-loop-if-!=/imm32/name -29263 0/imm32/no-inouts -29264 0/imm32/no-inouts -29265 0/imm32/no-outputs -29266 0/imm32/no-outputs +29243 _Primitive-compare-reg-with-literal/imm32/next +29244 _Primitive-compare-reg-with-literal: # (payload primitive) +29245 0x11/imm32/alloc-id:fake:payload +29246 # compare var1/reg n => 81 7/subop/compare %reg n/imm32 +29247 0x11/imm32/alloc-id:fake +29248 _string-compare/imm32/name +29249 0x11/imm32/alloc-id:fake +29250 Int-var-in-register-and-literal/imm32/inouts +29251 0/imm32/no-outputs +29252 0/imm32/no-outputs +29253 0x11/imm32/alloc-id:fake +29254 _string_81_subop_compare/imm32/subx-name +29255 1/imm32/rm32-is-first-inout +29256 0/imm32/no-r32 +29257 2/imm32/imm32-is-second-inout +29258 0/imm32/no-imm8 +29259 0/imm32/no-disp32 +29260 0/imm32/no-xm32 +29261 0/imm32/no-x32 +29262 0x11/imm32/alloc-id:fake +29263 _Primitive-compare-mem-with-literal/imm32/next +29264 _Primitive-compare-mem-with-literal: # (payload primitive) +29265 0x11/imm32/alloc-id:fake:payload +29266 # compare var1 n => 81 7/subop/compare *(ebp+___) n/imm32 29267 0x11/imm32/alloc-id:fake -29268 _string_0f_85_jump_loop/imm32/subx-name -29269 0/imm32/no-rm32 -29270 0/imm32/no-r32 -29271 0/imm32/no-imm32 -29272 0/imm32/no-imm8 -29273 0/imm32/no-disp32 -29274 0/imm32/no-xm32 -29275 0/imm32/no-x32 -29276 0x11/imm32/alloc-id:fake -29277 _Primitive-loop-if-addr<=/imm32/next -29278 _Primitive-loop-if-addr<=: # (payload primitive) -29279 0x11/imm32/alloc-id:fake:payload -29280 0x11/imm32/alloc-id:fake -29281 _string-loop-if-addr<=/imm32/name -29282 0/imm32/no-inouts -29283 0/imm32/no-inouts -29284 0/imm32/no-outputs -29285 0/imm32/no-outputs -29286 0x11/imm32/alloc-id:fake -29287 _string_0f_86_jump_loop/imm32/subx-name -29288 0/imm32/no-rm32 -29289 0/imm32/no-r32 -29290 0/imm32/no-imm32 -29291 0/imm32/no-imm8 -29292 0/imm32/no-disp32 -29293 0/imm32/no-xm32 -29294 0/imm32/no-x32 -29295 0x11/imm32/alloc-id:fake -29296 _Primitive-loop-if-addr>/imm32/next -29297 _Primitive-loop-if-addr>: # (payload primitive) -29298 0x11/imm32/alloc-id:fake:payload -29299 0x11/imm32/alloc-id:fake -29300 _string-loop-if-addr>/imm32/name -29301 0/imm32/no-inouts -29302 0/imm32/no-inouts -29303 0/imm32/no-outputs -29304 0/imm32/no-outputs -29305 0x11/imm32/alloc-id:fake -29306 _string_0f_87_jump_loop/imm32/subx-name -29307 0/imm32/no-rm32 -29308 0/imm32/no-r32 -29309 0/imm32/no-imm32 -29310 0/imm32/no-imm8 -29311 0/imm32/no-disp32 -29312 0/imm32/no-xm32 -29313 0/imm32/no-x32 +29268 _string-compare/imm32/name +29269 0x11/imm32/alloc-id:fake +29270 Int-var-and-literal/imm32/inouts +29271 0/imm32/no-outputs +29272 0/imm32/no-outputs +29273 0x11/imm32/alloc-id:fake +29274 _string_81_subop_compare/imm32/subx-name +29275 1/imm32/rm32-is-first-inout +29276 0/imm32/no-r32 +29277 2/imm32/imm32-is-second-inout +29278 0/imm32/no-imm8 +29279 0/imm32/no-disp32 +29280 0/imm32/no-xm32 +29281 0/imm32/no-x32 +29282 0x11/imm32/alloc-id:fake +29283 _Primitive-negate-reg/imm32/next +29284 # - negate +29285 _Primitive-negate-reg: # (payload primitive) +29286 0x11/imm32/alloc-id:fake:payload +29287 # var1/reg <- negate => f7 3/subop/negate var1/rm32 +29288 0x11/imm32/alloc-id:fake +29289 _string-negate/imm32/name +29290 0/imm32/no-inouts +29291 0/imm32/no-inouts +29292 0x11/imm32/alloc-id:fake +29293 Single-int-var-in-some-register/imm32/outputs +29294 0x11/imm32/alloc-id:fake +29295 _string_f7_subop_negate/imm32/subx-name +29296 3/imm32/rm32-is-first-output +29297 0/imm32/no-r32 +29298 0/imm32/no-imm32 +29299 0/imm32/no-imm8 +29300 0/imm32/no-disp32 +29301 0/imm32/no-xm32 +29302 0/imm32/no-x32 +29303 0x11/imm32/alloc-id:fake +29304 _Primitive-negate-mem/imm32/next +29305 _Primitive-negate-mem: # (payload primitive) +29306 0x11/imm32/alloc-id:fake:payload +29307 # negate var1 => f7 3/subop/negate var1/rm32 +29308 0x11/imm32/alloc-id:fake +29309 _string-negate/imm32/name +29310 0x11/imm32/alloc-id:fake +29311 Single-int-var-in-mem/imm32/inouts +29312 0/imm32/no-outputs +29313 0/imm32/no-outputs 29314 0x11/imm32/alloc-id:fake -29315 _Primitive-loop-if-</imm32/next -29316 _Primitive-loop-if-<: # (payload primitive) -29317 0x11/imm32/alloc-id:fake:payload -29318 0x11/imm32/alloc-id:fake -29319 _string-loop-if-</imm32/name -29320 0/imm32/no-inouts -29321 0/imm32/no-inouts -29322 0/imm32/no-outputs -29323 0/imm32/no-outputs -29324 0x11/imm32/alloc-id:fake -29325 _string_0f_8c_jump_loop/imm32/subx-name -29326 0/imm32/no-rm32 -29327 0/imm32/no-r32 -29328 0/imm32/no-imm32 -29329 0/imm32/no-imm8 -29330 0/imm32/no-disp32 -29331 0/imm32/no-xm32 -29332 0/imm32/no-x32 +29315 _string_f7_subop_negate/imm32/subx-name +29316 1/imm32/rm32-is-first-inout +29317 0/imm32/no-r32 +29318 0/imm32/no-imm32 +29319 0/imm32/no-imm8 +29320 0/imm32/no-disp32 +29321 0/imm32/no-xm32 +29322 0/imm32/no-x32 +29323 0x11/imm32/alloc-id:fake +29324 _Primitive-multiply-reg-by-reg/imm32/next +29325 # - multiply +29326 _Primitive-multiply-reg-by-reg: # (payload primitive) +29327 0x11/imm32/alloc-id:fake:payload +29328 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 +29329 0x11/imm32/alloc-id:fake +29330 _string-multiply/imm32/name +29331 0x11/imm32/alloc-id:fake +29332 Single-int-var-in-some-register/imm32/inouts 29333 0x11/imm32/alloc-id:fake -29334 _Primitive-loop-if->=/imm32/next -29335 _Primitive-loop-if->=: # (payload primitive) -29336 0x11/imm32/alloc-id:fake:payload -29337 0x11/imm32/alloc-id:fake -29338 _string-loop-if->=/imm32/name -29339 0/imm32/no-inouts -29340 0/imm32/no-inouts -29341 0/imm32/no-outputs -29342 0/imm32/no-outputs -29343 0x11/imm32/alloc-id:fake -29344 _string_0f_8d_jump_loop/imm32/subx-name -29345 0/imm32/no-rm32 -29346 0/imm32/no-r32 -29347 0/imm32/no-imm32 -29348 0/imm32/no-imm8 -29349 0/imm32/no-disp32 -29350 0/imm32/no-xm32 -29351 0/imm32/no-x32 -29352 0x11/imm32/alloc-id:fake -29353 _Primitive-loop-if-<=/imm32/next -29354 _Primitive-loop-if-<=: # (payload primitive) -29355 0x11/imm32/alloc-id:fake:payload -29356 0x11/imm32/alloc-id:fake -29357 _string-loop-if-<=/imm32/name -29358 0/imm32/no-inouts -29359 0/imm32/no-inouts -29360 0/imm32/no-outputs -29361 0/imm32/no-outputs -29362 0x11/imm32/alloc-id:fake -29363 _string_0f_8e_jump_loop/imm32/subx-name -29364 0/imm32/no-rm32 -29365 0/imm32/no-r32 -29366 0/imm32/no-imm32 -29367 0/imm32/no-imm8 -29368 0/imm32/no-disp32 -29369 0/imm32/no-xm32 -29370 0/imm32/no-x32 -29371 0x11/imm32/alloc-id:fake -29372 _Primitive-loop-if->/imm32/next -29373 _Primitive-loop-if->: # (payload primitive) -29374 0x11/imm32/alloc-id:fake:payload -29375 0x11/imm32/alloc-id:fake -29376 _string-loop-if->/imm32/name -29377 0/imm32/no-inouts -29378 0/imm32/no-inouts -29379 0/imm32/no-outputs -29380 0/imm32/no-outputs -29381 0x11/imm32/alloc-id:fake -29382 _string_0f_8f_jump_loop/imm32/subx-name -29383 0/imm32/no-rm32 -29384 0/imm32/no-r32 -29385 0/imm32/no-imm32 -29386 0/imm32/no-imm8 -29387 0/imm32/no-disp32 -29388 0/imm32/no-xm32 -29389 0/imm32/no-x32 +29334 Single-int-var-in-some-register/imm32/outputs +29335 0x11/imm32/alloc-id:fake +29336 _string_0f_af_multiply/imm32/subx-name +29337 1/imm32/rm32-is-first-inout +29338 3/imm32/r32-is-first-output +29339 0/imm32/no-imm32 +29340 0/imm32/no-imm8 +29341 0/imm32/no-disp32 +29342 0/imm32/no-xm32 +29343 0/imm32/no-x32 +29344 0x11/imm32/alloc-id:fake +29345 _Primitive-multiply-reg-by-mem/imm32/next +29346 _Primitive-multiply-reg-by-mem: # (payload primitive) +29347 0x11/imm32/alloc-id:fake:payload +29348 # var1/reg <- multiply var2 => 0f af/multiply var2/rm32 var1/r32 +29349 0x11/imm32/alloc-id:fake +29350 _string-multiply/imm32/name +29351 0x11/imm32/alloc-id:fake +29352 Single-int-var-in-mem/imm32/inouts +29353 0x11/imm32/alloc-id:fake +29354 Single-int-var-in-some-register/imm32/outputs +29355 0x11/imm32/alloc-id:fake +29356 _string_0f_af_multiply/imm32/subx-name +29357 1/imm32/rm32-is-first-inout +29358 3/imm32/r32-is-first-output +29359 0/imm32/no-imm32 +29360 0/imm32/no-imm8 +29361 0/imm32/no-disp32 +29362 0/imm32/no-xm32 +29363 0/imm32/no-x32 +29364 0x11/imm32/alloc-id:fake +29365 _Primitive-convert-mem-to-xreg/imm32/next +29366 # - convert int to floating point +29367 _Primitive-convert-mem-to-xreg: # (payload primitive) +29368 0x11/imm32/alloc-id:fake:payload +29369 # var1/xreg <- convert var2 => f3 0f 2a/convert-to-float var2/rm32 var1/x32 +29370 0x11/imm32/alloc-id:fake +29371 _string-convert/imm32/name +29372 0x11/imm32/alloc-id:fake +29373 Single-int-var-in-mem/imm32/inouts +29374 0x11/imm32/alloc-id:fake +29375 Single-float-var-in-some-register/imm32/outputs +29376 0x11/imm32/alloc-id:fake +29377 _string_f3_0f_2a_convert_to_float/imm32/subx-name +29378 1/imm32/rm32-is-first-inout +29379 0/imm32/no-r32 +29380 0/imm32/no-imm32 +29381 0/imm32/no-imm8 +29382 0/imm32/no-disp32 +29383 0/imm32/no-xm32 +29384 3/imm32/x32-is-first-output +29385 0x11/imm32/alloc-id:fake +29386 _Primitive-convert-reg-to-xreg/imm32/next +29387 _Primitive-convert-reg-to-xreg: # (payload primitive) +29388 0x11/imm32/alloc-id:fake:payload +29389 # var1/xreg <- convert var2/reg => f3 0f 2a/convert-to-float var2/rm32 var1/x32 29390 0x11/imm32/alloc-id:fake -29391 _Primitive-loop/imm32/next # we probably don't need an unconditional break -29392 _Primitive-loop: # (payload primitive) -29393 0x11/imm32/alloc-id:fake:payload +29391 _string-convert/imm32/name +29392 0x11/imm32/alloc-id:fake +29393 Single-int-var-in-some-register/imm32/inouts 29394 0x11/imm32/alloc-id:fake -29395 _string-loop/imm32/name -29396 0/imm32/no-inouts -29397 0/imm32/no-inouts -29398 0/imm32/no-outputs -29399 0/imm32/no-outputs -29400 0x11/imm32/alloc-id:fake -29401 _string_e9_jump_loop/imm32/subx-name -29402 0/imm32/no-rm32 -29403 0/imm32/no-r32 -29404 0/imm32/no-imm32 -29405 0/imm32/no-imm8 -29406 0/imm32/no-disp32 -29407 0/imm32/no-xm32 -29408 0/imm32/no-x32 -29409 0x11/imm32/alloc-id:fake -29410 _Primitive-break-if-addr<-named/imm32/next -29411 # - branches to named blocks -29412 _Primitive-break-if-addr<-named: # (payload primitive) -29413 0x11/imm32/alloc-id:fake:payload -29414 0x11/imm32/alloc-id:fake -29415 _string-break-if-addr</imm32/name -29416 0x11/imm32/alloc-id:fake -29417 Single-lit-var/imm32/inouts -29418 0/imm32/no-outputs -29419 0/imm32/no-outputs -29420 0x11/imm32/alloc-id:fake -29421 _string_0f_82_jump_label/imm32/subx-name -29422 0/imm32/no-rm32 -29423 0/imm32/no-r32 -29424 0/imm32/no-imm32 -29425 0/imm32/no-imm8 -29426 1/imm32/disp32-is-first-inout -29427 0/imm32/no-xm32 -29428 0/imm32/no-x32 -29429 0x11/imm32/alloc-id:fake -29430 _Primitive-break-if-addr>=-named/imm32/next -29431 _Primitive-break-if-addr>=-named: # (payload primitive) -29432 0x11/imm32/alloc-id:fake:payload +29395 Single-float-var-in-some-register/imm32/outputs +29396 0x11/imm32/alloc-id:fake +29397 _string_f3_0f_2a_convert_to_float/imm32/subx-name +29398 1/imm32/rm32-is-first-inout +29399 0/imm32/no-r32 +29400 0/imm32/no-imm32 +29401 0/imm32/no-imm8 +29402 0/imm32/no-disp32 +29403 0/imm32/no-xm32 +29404 3/imm32/x32-is-first-output +29405 0x11/imm32/alloc-id:fake +29406 _Primitive-convert-xmem-to-reg/imm32/next +29407 # - convert floating point to int +29408 _Primitive-convert-xmem-to-reg: # (payload primitive) +29409 0x11/imm32/alloc-id:fake:payload +29410 # var1/reg <- convert var2 => f3 0f 2d/convert-to-int var2/xm32 var1/r32 +29411 0x11/imm32/alloc-id:fake +29412 _string-convert/imm32/name +29413 0x11/imm32/alloc-id:fake +29414 Single-float-var-in-mem/imm32/inouts +29415 0x11/imm32/alloc-id:fake +29416 Single-int-var-in-some-register/imm32/outputs +29417 0x11/imm32/alloc-id:fake +29418 _string_f3_0f_2d_convert_to_int/imm32/subx-name +29419 0/imm32/no-rm32 +29420 3/imm32/r32-is-first-output +29421 0/imm32/no-imm32 +29422 0/imm32/no-imm8 +29423 0/imm32/no-disp32 +29424 1/imm32/xm32-is-first-inout +29425 0/imm32/no-x32 +29426 0x11/imm32/alloc-id:fake +29427 _Primitive-convert-xreg-to-reg/imm32/next +29428 _Primitive-convert-xreg-to-reg: # (payload primitive) +29429 0x11/imm32/alloc-id:fake:payload +29430 # var1/reg <- convert var2/xreg => f3 0f 2d/convert-to-int var2/xm32 var1/r32 +29431 0x11/imm32/alloc-id:fake +29432 _string-convert/imm32/name 29433 0x11/imm32/alloc-id:fake -29434 _string-break-if-addr>=/imm32/name +29434 Single-float-var-in-some-register/imm32/inouts 29435 0x11/imm32/alloc-id:fake -29436 Single-lit-var/imm32/inouts -29437 0/imm32/no-outputs -29438 0/imm32/no-outputs -29439 0x11/imm32/alloc-id:fake -29440 _string_0f_83_jump_label/imm32/subx-name -29441 0/imm32/no-rm32 -29442 0/imm32/no-r32 -29443 0/imm32/no-imm32 -29444 0/imm32/no-imm8 -29445 1/imm32/disp32-is-first-inout -29446 0/imm32/no-xm32 -29447 0/imm32/no-x32 -29448 0x11/imm32/alloc-id:fake -29449 _Primitive-break-if-=-named/imm32/next -29450 _Primitive-break-if-=-named: # (payload primitive) -29451 0x11/imm32/alloc-id:fake:payload -29452 0x11/imm32/alloc-id:fake -29453 _string-break-if-=/imm32/name -29454 0x11/imm32/alloc-id:fake -29455 Single-lit-var/imm32/inouts -29456 0/imm32/no-outputs -29457 0/imm32/no-outputs -29458 0x11/imm32/alloc-id:fake -29459 _string_0f_84_jump_label/imm32/subx-name -29460 0/imm32/no-rm32 -29461 0/imm32/no-r32 -29462 0/imm32/no-imm32 -29463 0/imm32/no-imm8 -29464 1/imm32/disp32-is-first-inout -29465 0/imm32/no-xm32 -29466 0/imm32/no-x32 -29467 0x11/imm32/alloc-id:fake -29468 _Primitive-break-if-!=-named/imm32/next -29469 _Primitive-break-if-!=-named: # (payload primitive) -29470 0x11/imm32/alloc-id:fake:payload +29436 Single-int-var-in-some-register/imm32/outputs +29437 0x11/imm32/alloc-id:fake +29438 _string_f3_0f_2d_convert_to_int/imm32/subx-name +29439 0/imm32/no-rm32 +29440 3/imm32/r32-is-first-output +29441 0/imm32/no-imm32 +29442 0/imm32/no-imm8 +29443 0/imm32/no-disp32 +29444 1/imm32/xm32-is-first-inout +29445 0/imm32/no-x32 +29446 0x11/imm32/alloc-id:fake +29447 _Primitive-truncate-xmem-to-reg/imm32/next +29448 _Primitive-truncate-xmem-to-reg: # (payload primitive) +29449 0x11/imm32/alloc-id:fake:payload +29450 # var1/reg <- truncate var2 => f3 0f 2c/truncate-to-int var2/xm32 var1/r32 +29451 0x11/imm32/alloc-id:fake +29452 _string-truncate/imm32/name +29453 0x11/imm32/alloc-id:fake +29454 Single-float-var-in-mem/imm32/inouts +29455 0x11/imm32/alloc-id:fake +29456 Single-int-var-in-some-register/imm32/outputs +29457 0x11/imm32/alloc-id:fake +29458 _string_f3_0f_2c_truncate_to_int/imm32/subx-name +29459 0/imm32/no-rm32 +29460 3/imm32/r32-is-first-output +29461 0/imm32/no-imm32 +29462 0/imm32/no-imm8 +29463 0/imm32/no-disp32 +29464 1/imm32/xm32-is-first-inout +29465 0/imm32/no-x32 +29466 0x11/imm32/alloc-id:fake +29467 _Primitive-truncate-xreg-to-reg/imm32/next +29468 _Primitive-truncate-xreg-to-reg: # (payload primitive) +29469 0x11/imm32/alloc-id:fake:payload +29470 # var1/reg <- truncate var2/xreg => f3 0f 2c/truncate-to-int var2/xm32 var1/r32 29471 0x11/imm32/alloc-id:fake -29472 _string-break-if-!=/imm32/name +29472 _string-truncate/imm32/name 29473 0x11/imm32/alloc-id:fake -29474 Single-lit-var/imm32/inouts -29475 0/imm32/no-outputs -29476 0/imm32/no-outputs +29474 Single-float-var-in-some-register/imm32/inouts +29475 0x11/imm32/alloc-id:fake +29476 Single-int-var-in-some-register/imm32/outputs 29477 0x11/imm32/alloc-id:fake -29478 _string_0f_85_jump_label/imm32/subx-name +29478 _string_f3_0f_2c_truncate_to_int/imm32/subx-name 29479 0/imm32/no-rm32 -29480 0/imm32/no-r32 +29480 3/imm32/r32-is-first-output 29481 0/imm32/no-imm32 29482 0/imm32/no-imm8 -29483 1/imm32/disp32-is-first-inout -29484 0/imm32/no-xm32 +29483 0/imm32/no-disp32 +29484 1/imm32/xm32-is-first-inout 29485 0/imm32/no-x32 29486 0x11/imm32/alloc-id:fake -29487 _Primitive-break-if-addr<=-named/imm32/next -29488 _Primitive-break-if-addr<=-named: # (payload primitive) -29489 0x11/imm32/alloc-id:fake:payload -29490 0x11/imm32/alloc-id:fake -29491 _string-break-if-addr<=/imm32/name +29487 _Primitive-reinterpret-xmem-as-reg/imm32/next +29488 # - reinterpret bytes (just for debugging) +29489 _Primitive-reinterpret-xmem-as-reg: # (payload primitive) +29490 0x11/imm32/alloc-id:fake:payload +29491 # var1/reg <- reinterpret var2 => 8b/-> var2/xm32 var1/r32 29492 0x11/imm32/alloc-id:fake -29493 Single-lit-var/imm32/inouts -29494 0/imm32/no-outputs -29495 0/imm32/no-outputs +29493 _string-reinterpret/imm32/name +29494 0x11/imm32/alloc-id:fake +29495 Single-float-var-in-mem/imm32/inouts 29496 0x11/imm32/alloc-id:fake -29497 _string_0f_86_jump_label/imm32/subx-name -29498 0/imm32/no-rm32 -29499 0/imm32/no-r32 -29500 0/imm32/no-imm32 -29501 0/imm32/no-imm8 -29502 1/imm32/disp32-is-first-inout -29503 0/imm32/no-xm32 -29504 0/imm32/no-x32 -29505 0x11/imm32/alloc-id:fake -29506 _Primitive-break-if-addr>-named/imm32/next -29507 _Primitive-break-if-addr>-named: # (payload primitive) -29508 0x11/imm32/alloc-id:fake:payload -29509 0x11/imm32/alloc-id:fake -29510 _string-break-if-addr>/imm32/name -29511 0x11/imm32/alloc-id:fake -29512 Single-lit-var/imm32/inouts -29513 0/imm32/no-outputs -29514 0/imm32/no-outputs -29515 0x11/imm32/alloc-id:fake -29516 _string_0f_87_jump_label/imm32/subx-name -29517 0/imm32/no-rm32 -29518 0/imm32/no-r32 -29519 0/imm32/no-imm32 -29520 0/imm32/no-imm8 -29521 1/imm32/disp32-is-first-inout -29522 0/imm32/no-xm32 -29523 0/imm32/no-x32 -29524 0x11/imm32/alloc-id:fake -29525 _Primitive-break-if-<-named/imm32/next -29526 _Primitive-break-if-<-named: # (payload primitive) -29527 0x11/imm32/alloc-id:fake:payload -29528 0x11/imm32/alloc-id:fake -29529 _string-break-if-</imm32/name -29530 0x11/imm32/alloc-id:fake -29531 Single-lit-var/imm32/inouts -29532 0/imm32/no-outputs -29533 0/imm32/no-outputs -29534 0x11/imm32/alloc-id:fake -29535 _string_0f_8c_jump_label/imm32/subx-name -29536 0/imm32/no-rm32 -29537 0/imm32/no-r32 -29538 0/imm32/no-imm32 -29539 0/imm32/no-imm8 -29540 1/imm32/disp32-is-first-inout -29541 0/imm32/no-xm32 -29542 0/imm32/no-x32 -29543 0x11/imm32/alloc-id:fake -29544 _Primitive-break-if->=-named/imm32/next -29545 _Primitive-break-if->=-named: # (payload primitive) -29546 0x11/imm32/alloc-id:fake:payload -29547 0x11/imm32/alloc-id:fake -29548 _string-break-if->=/imm32/name -29549 0x11/imm32/alloc-id:fake -29550 Single-lit-var/imm32/inouts -29551 0/imm32/no-outputs -29552 0/imm32/no-outputs +29497 Single-int-var-in-some-register/imm32/outputs +29498 0x11/imm32/alloc-id:fake +29499 _string_8b_->/imm32/subx-name +29500 0/imm32/no-rm32 +29501 3/imm32/r32-is-first-output +29502 0/imm32/no-imm32 +29503 0/imm32/no-imm8 +29504 0/imm32/no-disp32 +29505 1/imm32/xm32-is-first-inout +29506 0/imm32/no-x32 +29507 0x11/imm32/alloc-id:fake +29508 _Primitive-reinterpret-mem-as-xreg/imm32/next +29509 _Primitive-reinterpret-mem-as-xreg: # (payload primitive) +29510 0x11/imm32/alloc-id:fake:payload +29511 # var1/xreg <- reinterpret var2 => f3 0f 10/-> var2/rm32 var1/x32 +29512 0x11/imm32/alloc-id:fake +29513 _string-reinterpret/imm32/name +29514 0x11/imm32/alloc-id:fake +29515 Single-int-var-in-mem/imm32/inouts +29516 0x11/imm32/alloc-id:fake +29517 Single-float-var-in-some-register/imm32/outputs +29518 0x11/imm32/alloc-id:fake +29519 _string_f3_0f_10_copy/imm32/subx-name +29520 1/imm32/rm32-is-first-inout +29521 0/imm32/no-r32 +29522 0/imm32/no-imm32 +29523 0/imm32/no-imm8 +29524 0/imm32/no-disp32 +29525 0/imm32/no-xm32 +29526 3/imm32/x32-is-first-output +29527 0x11/imm32/alloc-id:fake +29528 _Primitive-copy-xreg-to-xreg/imm32/next +29529 # - floating-point copy +29530 _Primitive-copy-xreg-to-xreg: # (payload primitive) +29531 0x11/imm32/alloc-id:fake:payload +29532 # var1/xreg <- copy var2/xreg => f3 0f 11/<- var1/xm32 var2/x32 +29533 0x11/imm32/alloc-id:fake +29534 _string-copy/imm32/name +29535 0x11/imm32/alloc-id:fake +29536 Single-float-var-in-some-register/imm32/inouts +29537 0x11/imm32/alloc-id:fake +29538 Single-float-var-in-some-register/imm32/outputs +29539 0x11/imm32/alloc-id:fake +29540 _string_f3_0f_11_copy/imm32/subx-name +29541 0/imm32/no-rm32 +29542 0/imm32/no-r32 +29543 0/imm32/no-imm32 +29544 0/imm32/no-imm8 +29545 0/imm32/no-disp32 +29546 3/imm32/xm32-is-first-output +29547 1/imm32/x32-is-first-inout +29548 0x11/imm32/alloc-id:fake +29549 _Primitive-copy-xreg-to-mem/imm32/next +29550 _Primitive-copy-xreg-to-mem: # (payload primitive) +29551 0x11/imm32/alloc-id:fake:payload +29552 # copy-to var1 var2/xreg => f3 0f 11/<- var1 var2/x32 29553 0x11/imm32/alloc-id:fake -29554 _string_0f_8d_jump_label/imm32/subx-name -29555 0/imm32/no-rm32 -29556 0/imm32/no-r32 -29557 0/imm32/no-imm32 -29558 0/imm32/no-imm8 -29559 1/imm32/disp32-is-first-inout -29560 0/imm32/no-xm32 -29561 0/imm32/no-x32 -29562 0x11/imm32/alloc-id:fake -29563 _Primitive-break-if-<=-named/imm32/next -29564 _Primitive-break-if-<=-named: # (payload primitive) -29565 0x11/imm32/alloc-id:fake:payload -29566 0x11/imm32/alloc-id:fake -29567 _string-break-if-<=/imm32/name +29554 _string-copy-to/imm32/name +29555 0x11/imm32/alloc-id:fake +29556 Two-args-float-stack-float-reg/imm32/inouts +29557 0/imm32/no-outputs +29558 0/imm32/no-outputs +29559 0x11/imm32/alloc-id:fake +29560 _string_f3_0f_11_copy/imm32/subx-name +29561 0/imm32/no-rm32 +29562 0/imm32/no-r32 +29563 0/imm32/no-imm32 +29564 0/imm32/no-imm8 +29565 0/imm32/no-disp32 +29566 1/imm32/xm32-is-first-inout +29567 2/imm32/x32-is-second-inout 29568 0x11/imm32/alloc-id:fake -29569 Single-lit-var/imm32/inouts -29570 0/imm32/no-outputs -29571 0/imm32/no-outputs -29572 0x11/imm32/alloc-id:fake -29573 _string_0f_8e_jump_label/imm32/subx-name -29574 0/imm32/no-rm32 -29575 0/imm32/no-r32 -29576 0/imm32/no-imm32 -29577 0/imm32/no-imm8 -29578 1/imm32/disp32-is-first-inout -29579 0/imm32/no-xm32 -29580 0/imm32/no-x32 -29581 0x11/imm32/alloc-id:fake -29582 _Primitive-break-if->-named/imm32/next -29583 _Primitive-break-if->-named: # (payload primitive) -29584 0x11/imm32/alloc-id:fake:payload -29585 0x11/imm32/alloc-id:fake -29586 _string-break-if->/imm32/name -29587 0x11/imm32/alloc-id:fake -29588 Single-lit-var/imm32/inouts -29589 0/imm32/no-outputs -29590 0/imm32/no-outputs -29591 0x11/imm32/alloc-id:fake -29592 _string_0f_8f_jump_label/imm32/subx-name -29593 0/imm32/no-rm32 -29594 0/imm32/no-r32 -29595 0/imm32/no-imm32 -29596 0/imm32/no-imm8 -29597 1/imm32/disp32-is-first-inout -29598 0/imm32/no-xm32 -29599 0/imm32/no-x32 +29569 _Primitive-copy-mem-to-xreg/imm32/next +29570 _Primitive-copy-mem-to-xreg: # (payload primitive) +29571 0x11/imm32/alloc-id:fake:payload +29572 # var1/xreg <- copy var2 => f3 0f 10/-> var2/rm32 var1/x32 +29573 0x11/imm32/alloc-id:fake +29574 _string-copy/imm32/name +29575 0x11/imm32/alloc-id:fake +29576 Single-float-var-in-mem/imm32/inouts +29577 0x11/imm32/alloc-id:fake +29578 Single-float-var-in-some-register/imm32/outputs +29579 0x11/imm32/alloc-id:fake +29580 _string_f3_0f_10_copy/imm32/subx-name +29581 0/imm32/no-rm32 +29582 0/imm32/no-r32 +29583 0/imm32/no-imm32 +29584 0/imm32/no-imm8 +29585 0/imm32/no-disp32 +29586 1/imm32/xm32-is-first-inout +29587 3/imm32/x32-is-first-output +29588 0x11/imm32/alloc-id:fake +29589 _Primitive-address-of-xmem/imm32/next +29590 # - floating-point-address +29591 _Primitive-address-of-xmem: # (payload primitive) +29592 0x11/imm32/alloc-id:fake:payload +29593 # var1/reg <- address var2 => 8d/copy-address var2/rm32 var1/r32 +29594 0x11/imm32/alloc-id:fake +29595 _string-address/imm32/name +29596 0x11/imm32/alloc-id:fake +29597 Single-float-var-in-mem/imm32/inouts +29598 0x11/imm32/alloc-id:fake +29599 Single-addr-var-in-some-register/imm32/outputs 29600 0x11/imm32/alloc-id:fake -29601 _Primitive-break-named/imm32/next -29602 _Primitive-break-named: # (payload primitive) -29603 0x11/imm32/alloc-id:fake:payload -29604 0x11/imm32/alloc-id:fake -29605 _string-break/imm32/name -29606 0x11/imm32/alloc-id:fake -29607 Single-lit-var/imm32/inouts -29608 0/imm32/no-outputs -29609 0/imm32/no-outputs -29610 0x11/imm32/alloc-id:fake -29611 _string_e9_jump_label/imm32/subx-name -29612 0/imm32/no-rm32 -29613 0/imm32/no-r32 -29614 0/imm32/no-imm32 -29615 0/imm32/no-imm8 -29616 1/imm32/disp32-is-first-inout -29617 0/imm32/no-xm32 -29618 0/imm32/no-x32 +29601 _string_8d_copy_address/imm32/subx-name +29602 1/imm32/rm32-is-first-inout +29603 3/imm32/r32-is-first-output +29604 0/imm32/no-imm32 +29605 0/imm32/no-imm8 +29606 0/imm32/no-disp32 +29607 0/imm32/no-xm32 +29608 0/imm32/no-x32 +29609 0x11/imm32/alloc-id:fake +29610 _Primitive-add-xreg-to-xreg/imm32/next +29611 # - floating-point add +29612 _Primitive-add-xreg-to-xreg: # (payload primitive) +29613 0x11/imm32/alloc-id:fake:payload +29614 # var1/xreg <- add var2/xreg => f3 0f 58/add var1/xm32 var2/x32 +29615 0x11/imm32/alloc-id:fake +29616 _string-add/imm32/name +29617 0x11/imm32/alloc-id:fake +29618 Single-float-var-in-some-register/imm32/inouts 29619 0x11/imm32/alloc-id:fake -29620 _Primitive-loop-if-addr<-named/imm32/next -29621 _Primitive-loop-if-addr<-named: # (payload primitive) -29622 0x11/imm32/alloc-id:fake:payload -29623 0x11/imm32/alloc-id:fake -29624 _string-loop-if-addr</imm32/name -29625 0x11/imm32/alloc-id:fake -29626 Single-lit-var/imm32/inouts -29627 0/imm32/no-outputs -29628 0/imm32/no-outputs -29629 0x11/imm32/alloc-id:fake -29630 _string_0f_82_jump_label/imm32/subx-name -29631 0/imm32/no-rm32 -29632 0/imm32/no-r32 -29633 0/imm32/no-imm32 -29634 0/imm32/no-imm8 -29635 1/imm32/disp32-is-first-inout -29636 0/imm32/no-xm32 -29637 0/imm32/no-x32 -29638 0x11/imm32/alloc-id:fake -29639 _Primitive-loop-if-addr>=-named/imm32/next -29640 _Primitive-loop-if-addr>=-named: # (payload primitive) -29641 0x11/imm32/alloc-id:fake:payload -29642 0x11/imm32/alloc-id:fake -29643 _string-loop-if-addr>=/imm32/name -29644 0x11/imm32/alloc-id:fake -29645 Single-lit-var/imm32/inouts -29646 0/imm32/no-outputs -29647 0/imm32/no-outputs -29648 0x11/imm32/alloc-id:fake -29649 _string_0f_83_jump_label/imm32/subx-name -29650 0/imm32/no-rm32 -29651 0/imm32/no-r32 -29652 0/imm32/no-imm32 -29653 0/imm32/no-imm8 -29654 1/imm32/disp32-is-first-inout -29655 0/imm32/no-xm32 -29656 0/imm32/no-x32 -29657 0x11/imm32/alloc-id:fake -29658 _Primitive-loop-if-=-named/imm32/next -29659 _Primitive-loop-if-=-named: # (payload primitive) -29660 0x11/imm32/alloc-id:fake:payload -29661 0x11/imm32/alloc-id:fake -29662 _string-loop-if-=/imm32/name -29663 0x11/imm32/alloc-id:fake -29664 Single-lit-var/imm32/inouts -29665 0/imm32/no-outputs -29666 0/imm32/no-outputs -29667 0x11/imm32/alloc-id:fake -29668 _string_0f_84_jump_label/imm32/subx-name -29669 0/imm32/no-rm32 -29670 0/imm32/no-r32 -29671 0/imm32/no-imm32 -29672 0/imm32/no-imm8 -29673 1/imm32/disp32-is-first-inout -29674 0/imm32/no-xm32 -29675 0/imm32/no-x32 +29620 Single-float-var-in-some-register/imm32/outputs +29621 0x11/imm32/alloc-id:fake +29622 _string_f3_0f_58_add/imm32/subx-name +29623 0/imm32/no-rm32 +29624 0/imm32/no-r32 +29625 0/imm32/no-imm32 +29626 0/imm32/no-imm8 +29627 0/imm32/no-disp32 +29628 1/imm32/xm32-is-first-inout +29629 3/imm32/x32-is-first-output +29630 0x11/imm32/alloc-id:fake +29631 _Primitive-add-mem-to-xreg/imm32/next +29632 _Primitive-add-mem-to-xreg: # (payload primitive) +29633 0x11/imm32/alloc-id:fake:payload +29634 # var1/xreg <- add var2 => f3 0f 58/add var2/xm32 var1/x32 +29635 0x11/imm32/alloc-id:fake +29636 _string-add/imm32/name +29637 0x11/imm32/alloc-id:fake +29638 Single-float-var-in-mem/imm32/inouts +29639 0x11/imm32/alloc-id:fake +29640 Single-float-var-in-some-register/imm32/outputs +29641 0x11/imm32/alloc-id:fake +29642 _string_f3_0f_58_add/imm32/subx-name +29643 0/imm32/no-rm32 +29644 0/imm32/no-r32 +29645 0/imm32/no-imm32 +29646 0/imm32/no-imm8 +29647 0/imm32/no-disp32 +29648 1/imm32/xm32-is-first-inout +29649 3/imm32/x32-is-first-output +29650 0x11/imm32/alloc-id:fake +29651 _Primitive-subtract-xreg-from-xreg/imm32/next +29652 # - floating-point subtract +29653 _Primitive-subtract-xreg-from-xreg: # (payload primitive) +29654 0x11/imm32/alloc-id:fake:payload +29655 # var1/xreg <- subtract var2/xreg => f3 0f 5c/subtract var1/xm32 var2/x32 +29656 0x11/imm32/alloc-id:fake +29657 _string-subtract/imm32/name +29658 0x11/imm32/alloc-id:fake +29659 Single-float-var-in-some-register/imm32/inouts +29660 0x11/imm32/alloc-id:fake +29661 Single-float-var-in-some-register/imm32/outputs +29662 0x11/imm32/alloc-id:fake +29663 _string_f3_0f_5c_subtract/imm32/subx-name +29664 0/imm32/no-rm32 +29665 0/imm32/no-r32 +29666 0/imm32/no-imm32 +29667 0/imm32/no-imm8 +29668 0/imm32/no-disp32 +29669 1/imm32/xm32-is-first-inout +29670 3/imm32/x32-is-first-output +29671 0x11/imm32/alloc-id:fake +29672 _Primitive-subtract-mem-from-xreg/imm32/next +29673 _Primitive-subtract-mem-from-xreg: # (payload primitive) +29674 0x11/imm32/alloc-id:fake:payload +29675 # var1/xreg <- subtract var2 => f3 0f 5c/subtract var2/xm32 var1/x32 29676 0x11/imm32/alloc-id:fake -29677 _Primitive-loop-if-!=-named/imm32/next -29678 _Primitive-loop-if-!=-named: # (payload primitive) -29679 0x11/imm32/alloc-id:fake:payload +29677 _string-subtract/imm32/name +29678 0x11/imm32/alloc-id:fake +29679 Single-float-var-in-mem/imm32/inouts 29680 0x11/imm32/alloc-id:fake -29681 _string-loop-if-!=/imm32/name +29681 Single-float-var-in-some-register/imm32/outputs 29682 0x11/imm32/alloc-id:fake -29683 Single-lit-var/imm32/inouts -29684 0/imm32/no-outputs -29685 0/imm32/no-outputs -29686 0x11/imm32/alloc-id:fake -29687 _string_0f_85_jump_label/imm32/subx-name -29688 0/imm32/no-rm32 -29689 0/imm32/no-r32 -29690 0/imm32/no-imm32 -29691 0/imm32/no-imm8 -29692 1/imm32/disp32-is-first-inout -29693 0/imm32/no-xm32 -29694 0/imm32/no-x32 -29695 0x11/imm32/alloc-id:fake -29696 _Primitive-loop-if-addr<=-named/imm32/next -29697 _Primitive-loop-if-addr<=-named: # (payload primitive) -29698 0x11/imm32/alloc-id:fake:payload +29683 _string_f3_0f_5c_subtract/imm32/subx-name +29684 0/imm32/no-rm32 +29685 0/imm32/no-r32 +29686 0/imm32/no-imm32 +29687 0/imm32/no-imm8 +29688 0/imm32/no-disp32 +29689 1/imm32/xm32-is-first-inout +29690 3/imm32/x32-is-first-output +29691 0x11/imm32/alloc-id:fake +29692 _Primitive-multiply-xreg-by-xreg/imm32/next +29693 # - floating-point multiply +29694 _Primitive-multiply-xreg-by-xreg: # (payload primitive) +29695 0x11/imm32/alloc-id:fake:payload +29696 # var1/xreg <- multiply var2 => f3 0f 59/multiply var2/xm32 var1/x32 +29697 0x11/imm32/alloc-id:fake +29698 _string-multiply/imm32/name 29699 0x11/imm32/alloc-id:fake -29700 _string-loop-if-addr<=/imm32/name +29700 Single-float-var-in-some-register/imm32/inouts 29701 0x11/imm32/alloc-id:fake -29702 Single-lit-var/imm32/inouts -29703 0/imm32/no-outputs -29704 0/imm32/no-outputs -29705 0x11/imm32/alloc-id:fake -29706 _string_0f_86_jump_label/imm32/subx-name -29707 0/imm32/no-rm32 -29708 0/imm32/no-r32 -29709 0/imm32/no-imm32 -29710 0/imm32/no-imm8 -29711 1/imm32/disp32-is-first-inout -29712 0/imm32/no-xm32 -29713 0/imm32/no-x32 -29714 0x11/imm32/alloc-id:fake -29715 _Primitive-loop-if-addr>-named/imm32/next -29716 _Primitive-loop-if-addr>-named: # (payload primitive) -29717 0x11/imm32/alloc-id:fake:payload -29718 0x11/imm32/alloc-id:fake -29719 _string-loop-if-addr>/imm32/name -29720 0x11/imm32/alloc-id:fake -29721 Single-lit-var/imm32/inouts -29722 0/imm32/no-outputs -29723 0/imm32/no-outputs -29724 0x11/imm32/alloc-id:fake -29725 _string_0f_87_jump_label/imm32/subx-name -29726 0/imm32/no-rm32 -29727 0/imm32/no-r32 -29728 0/imm32/no-imm32 -29729 0/imm32/no-imm8 -29730 1/imm32/disp32-is-first-inout -29731 0/imm32/no-xm32 -29732 0/imm32/no-x32 -29733 0x11/imm32/alloc-id:fake -29734 _Primitive-loop-if-<-named/imm32/next -29735 _Primitive-loop-if-<-named: # (payload primitive) +29702 Single-float-var-in-some-register/imm32/outputs +29703 0x11/imm32/alloc-id:fake +29704 _string_f3_0f_59_multiply/imm32/subx-name +29705 0/imm32/no-rm32 +29706 0/imm32/no-r32 +29707 0/imm32/no-imm32 +29708 0/imm32/no-imm8 +29709 0/imm32/no-disp32 +29710 1/imm32/xm32-is-first-inout +29711 3/imm32/x32-is-first-output +29712 0x11/imm32/alloc-id:fake +29713 _Primitive-multiply-xreg-by-mem/imm32/next +29714 _Primitive-multiply-xreg-by-mem: # (payload primitive) +29715 0x11/imm32/alloc-id:fake:payload +29716 # var1/xreg <- multiply var2 => 53 0f 59/multiply var2/xm32 var1/x32 +29717 0x11/imm32/alloc-id:fake +29718 _string-multiply/imm32/name +29719 0x11/imm32/alloc-id:fake +29720 Single-float-var-in-mem/imm32/inouts +29721 0x11/imm32/alloc-id:fake +29722 Single-float-var-in-some-register/imm32/outputs +29723 0x11/imm32/alloc-id:fake +29724 _string_f3_0f_59_multiply/imm32/subx-name +29725 0/imm32/no-rm32 +29726 0/imm32/no-r32 +29727 0/imm32/no-imm32 +29728 0/imm32/no-imm8 +29729 0/imm32/no-disp32 +29730 1/imm32/xm32-is-first-inout +29731 3/imm32/x32-is-first-output +29732 0x11/imm32/alloc-id:fake +29733 _Primitive-divide-xreg-by-xreg/imm32/next +29734 # - floating-point divide +29735 _Primitive-divide-xreg-by-xreg: # (payload primitive) 29736 0x11/imm32/alloc-id:fake:payload -29737 0x11/imm32/alloc-id:fake -29738 _string-loop-if-</imm32/name -29739 0x11/imm32/alloc-id:fake -29740 Single-lit-var/imm32/inouts -29741 0/imm32/no-outputs -29742 0/imm32/no-outputs -29743 0x11/imm32/alloc-id:fake -29744 _string_0f_8c_jump_label/imm32/subx-name -29745 0/imm32/no-rm32 -29746 0/imm32/no-r32 -29747 0/imm32/no-imm32 -29748 0/imm32/no-imm8 -29749 1/imm32/disp32-is-first-inout -29750 0/imm32/no-xm32 -29751 0/imm32/no-x32 -29752 0x11/imm32/alloc-id:fake -29753 _Primitive-loop-if->=-named/imm32/next -29754 _Primitive-loop-if->=-named: # (payload primitive) -29755 0x11/imm32/alloc-id:fake:payload -29756 0x11/imm32/alloc-id:fake -29757 _string-loop-if->=/imm32/name +29737 # var1/xreg <- divide var2 => f3 0f 5e/divide var2/xm32 var1/x32 +29738 0x11/imm32/alloc-id:fake +29739 _string-divide/imm32/name +29740 0x11/imm32/alloc-id:fake +29741 Single-float-var-in-some-register/imm32/inouts +29742 0x11/imm32/alloc-id:fake +29743 Single-float-var-in-some-register/imm32/outputs +29744 0x11/imm32/alloc-id:fake +29745 _string_f3_0f_5e_divide/imm32/subx-name +29746 0/imm32/no-rm32 +29747 0/imm32/no-r32 +29748 0/imm32/no-imm32 +29749 0/imm32/no-imm8 +29750 0/imm32/no-disp32 +29751 1/imm32/xm32-is-first-inout +29752 3/imm32/x32-is-first-output +29753 0x11/imm32/alloc-id:fake +29754 _Primitive-divide-xreg-by-mem/imm32/next +29755 _Primitive-divide-xreg-by-mem: # (payload primitive) +29756 0x11/imm32/alloc-id:fake:payload +29757 # var1/xreg <- divide var2 => f3 0f 5e/divide var2/xm32 var1/x32 29758 0x11/imm32/alloc-id:fake -29759 Single-lit-var/imm32/inouts -29760 0/imm32/no-outputs -29761 0/imm32/no-outputs +29759 _string-divide/imm32/name +29760 0x11/imm32/alloc-id:fake +29761 Single-float-var-in-mem/imm32/inouts 29762 0x11/imm32/alloc-id:fake -29763 _string_0f_8d_jump_label/imm32/subx-name -29764 0/imm32/no-rm32 -29765 0/imm32/no-r32 -29766 0/imm32/no-imm32 -29767 0/imm32/no-imm8 -29768 1/imm32/disp32-is-first-inout -29769 0/imm32/no-xm32 -29770 0/imm32/no-x32 -29771 0x11/imm32/alloc-id:fake -29772 _Primitive-loop-if-<=-named/imm32/next -29773 _Primitive-loop-if-<=-named: # (payload primitive) -29774 0x11/imm32/alloc-id:fake:payload -29775 0x11/imm32/alloc-id:fake -29776 _string-loop-if-<=/imm32/name -29777 0x11/imm32/alloc-id:fake -29778 Single-lit-var/imm32/inouts -29779 0/imm32/no-outputs -29780 0/imm32/no-outputs +29763 Single-float-var-in-some-register/imm32/outputs +29764 0x11/imm32/alloc-id:fake +29765 _string_f3_0f_5e_divide/imm32/subx-name +29766 0/imm32/no-rm32 +29767 0/imm32/no-r32 +29768 0/imm32/no-imm32 +29769 0/imm32/no-imm8 +29770 0/imm32/no-disp32 +29771 1/imm32/xm32-is-first-inout +29772 3/imm32/x32-is-first-output +29773 0x11/imm32/alloc-id:fake +29774 _Primitive-max-xreg-with-xreg/imm32/next +29775 # - floating-point maximum +29776 _Primitive-max-xreg-with-xreg: # (payload primitive) +29777 0x11/imm32/alloc-id:fake:payload +29778 # var1/xreg <- max var2 => f3 0f 5f/max var2/xm32 var1/x32 +29779 0x11/imm32/alloc-id:fake +29780 _string-max/imm32/name 29781 0x11/imm32/alloc-id:fake -29782 _string_0f_8e_jump_label/imm32/subx-name -29783 0/imm32/no-rm32 -29784 0/imm32/no-r32 -29785 0/imm32/no-imm32 -29786 0/imm32/no-imm8 -29787 1/imm32/disp32-is-first-inout -29788 0/imm32/no-xm32 -29789 0/imm32/no-x32 -29790 0x11/imm32/alloc-id:fake -29791 _Primitive-loop-if->-named/imm32/next -29792 _Primitive-loop-if->-named: # (payload primitive) -29793 0x11/imm32/alloc-id:fake:payload +29782 Single-float-var-in-some-register/imm32/inouts +29783 0x11/imm32/alloc-id:fake +29784 Single-float-var-in-some-register/imm32/outputs +29785 0x11/imm32/alloc-id:fake +29786 _string_f3_0f_5f_max/imm32/subx-name +29787 0/imm32/no-rm32 +29788 0/imm32/no-r32 +29789 0/imm32/no-imm32 +29790 0/imm32/no-imm8 +29791 0/imm32/no-disp32 +29792 1/imm32/xm32-is-first-inout +29793 3/imm32/x32-is-first-output 29794 0x11/imm32/alloc-id:fake -29795 _string-loop-if->/imm32/name -29796 0x11/imm32/alloc-id:fake -29797 Single-lit-var/imm32/inouts -29798 0/imm32/no-outputs -29799 0/imm32/no-outputs -29800 0x11/imm32/alloc-id:fake -29801 _string_0f_8f_jump_label/imm32/subx-name -29802 0/imm32/no-rm32 -29803 0/imm32/no-r32 -29804 0/imm32/no-imm32 -29805 0/imm32/no-imm8 -29806 1/imm32/disp32-is-first-inout -29807 0/imm32/no-xm32 -29808 0/imm32/no-x32 -29809 0x11/imm32/alloc-id:fake -29810 _Primitive-loop-named/imm32/next # we probably don't need an unconditional break -29811 _Primitive-loop-named: # (payload primitive) -29812 0x11/imm32/alloc-id:fake:payload -29813 0x11/imm32/alloc-id:fake -29814 _string-loop/imm32/name -29815 0x11/imm32/alloc-id:fake -29816 Single-lit-var/imm32/inouts -29817 0/imm32/no-outputs -29818 0/imm32/no-outputs -29819 0x11/imm32/alloc-id:fake -29820 _string_e9_jump_label/imm32/subx-name -29821 0/imm32/no-rm32 -29822 0/imm32/no-r32 -29823 0/imm32/no-imm32 -29824 0/imm32/no-imm8 -29825 1/imm32/disp32-is-first-inout -29826 0/imm32/no-xm32 -29827 0/imm32/no-x32 -29828 0x11/imm32/alloc-id:fake -29829 _Primitive-break-if-float</imm32/next -29830 # - branches based on floating-point comparisons -29831 _Primitive-break-if-float<: # (payload primitive) -29832 0x11/imm32/alloc-id:fake:payload -29833 0x11/imm32/alloc-id:fake -29834 _string-break-if-float</imm32/name -29835 0/imm32/no-inouts -29836 0/imm32/no-inouts -29837 0/imm32/no-outputs -29838 0/imm32/no-outputs -29839 0x11/imm32/alloc-id:fake -29840 _string_0f_82_jump_break/imm32/subx-name -29841 0/imm32/no-rm32 -29842 0/imm32/no-r32 -29843 0/imm32/no-imm32 -29844 0/imm32/no-imm8 -29845 0/imm32/no-disp32 -29846 0/imm32/no-xm32 -29847 0/imm32/no-x32 -29848 0x11/imm32/alloc-id:fake -29849 _Primitive-break-if-float>=/imm32/next -29850 _Primitive-break-if-float>=: # (payload primitive) -29851 0x11/imm32/alloc-id:fake:payload -29852 0x11/imm32/alloc-id:fake -29853 _string-break-if-float>=/imm32/name -29854 0/imm32/no-inouts -29855 0/imm32/no-inouts -29856 0/imm32/no-outputs -29857 0/imm32/no-outputs -29858 0x11/imm32/alloc-id:fake -29859 _string_0f_83_jump_break/imm32/subx-name -29860 0/imm32/no-rm32 -29861 0/imm32/no-r32 -29862 0/imm32/no-imm32 -29863 0/imm32/no-imm8 -29864 0/imm32/no-disp32 -29865 0/imm32/no-xm32 -29866 0/imm32/no-x32 +29795 _Primitive-max-xreg-with-mem/imm32/next +29796 _Primitive-max-xreg-with-mem: # (payload primitive) +29797 0x11/imm32/alloc-id:fake:payload +29798 # var1/xreg <- divide var2 => f3 0f 5f/max var2/xm32 var1/x32 +29799 0x11/imm32/alloc-id:fake +29800 _string-max/imm32/name +29801 0x11/imm32/alloc-id:fake +29802 Single-float-var-in-mem/imm32/inouts +29803 0x11/imm32/alloc-id:fake +29804 Single-float-var-in-some-register/imm32/outputs +29805 0x11/imm32/alloc-id:fake +29806 _string_f3_0f_5f_max/imm32/subx-name +29807 0/imm32/no-rm32 +29808 0/imm32/no-r32 +29809 0/imm32/no-imm32 +29810 0/imm32/no-imm8 +29811 0/imm32/no-disp32 +29812 1/imm32/xm32-is-first-inout +29813 3/imm32/x32-is-first-output +29814 0x11/imm32/alloc-id:fake +29815 _Primitive-min-xreg-with-xreg/imm32/next +29816 # - floating-point minimum +29817 _Primitive-min-xreg-with-xreg: # (payload primitive) +29818 0x11/imm32/alloc-id:fake:payload +29819 # var1/xreg <- divide var2 => f3 0f 5d/min var2/xm32 var1/x32 +29820 0x11/imm32/alloc-id:fake +29821 _string-min/imm32/name +29822 0x11/imm32/alloc-id:fake +29823 Single-float-var-in-some-register/imm32/inouts +29824 0x11/imm32/alloc-id:fake +29825 Single-float-var-in-some-register/imm32/outputs +29826 0x11/imm32/alloc-id:fake +29827 _string_f3_0f_5d_min/imm32/subx-name +29828 0/imm32/no-rm32 +29829 0/imm32/no-r32 +29830 0/imm32/no-imm32 +29831 0/imm32/no-imm8 +29832 0/imm32/no-disp32 +29833 1/imm32/xm32-is-first-inout +29834 3/imm32/x32-is-first-output +29835 0x11/imm32/alloc-id:fake +29836 _Primitive-min-xreg-with-mem/imm32/next +29837 _Primitive-min-xreg-with-mem: # (payload primitive) +29838 0x11/imm32/alloc-id:fake:payload +29839 # var1/xreg <- divide var2 => f3 0f 5d/min var2/xm32 var1/x32 +29840 0x11/imm32/alloc-id:fake +29841 _string-min/imm32/name +29842 0x11/imm32/alloc-id:fake +29843 Single-float-var-in-mem/imm32/inouts +29844 0x11/imm32/alloc-id:fake +29845 Single-float-var-in-some-register/imm32/outputs +29846 0x11/imm32/alloc-id:fake +29847 _string_f3_0f_5d_min/imm32/subx-name +29848 0/imm32/no-rm32 +29849 0/imm32/no-r32 +29850 0/imm32/no-imm32 +29851 0/imm32/no-imm8 +29852 0/imm32/no-disp32 +29853 1/imm32/xm32-is-first-inout +29854 3/imm32/x32-is-first-output +29855 0x11/imm32/alloc-id:fake +29856 _Primitive-reciprocal-xreg-to-xreg/imm32/next +29857 # - floating-point reciprocal +29858 _Primitive-reciprocal-xreg-to-xreg: # (payload primitive) +29859 0x11/imm32/alloc-id:fake:payload +29860 # var1/xreg <- reciprocal var2 => f3 0f 53/reciprocal var2/xm32 var1/x32 +29861 0x11/imm32/alloc-id:fake +29862 _string-reciprocal/imm32/name +29863 0x11/imm32/alloc-id:fake +29864 Single-float-var-in-some-register/imm32/inouts +29865 0x11/imm32/alloc-id:fake +29866 Single-float-var-in-some-register/imm32/outputs 29867 0x11/imm32/alloc-id:fake -29868 _Primitive-break-if-float<=/imm32/next -29869 _Primitive-break-if-float<=: # (payload primitive) -29870 0x11/imm32/alloc-id:fake:payload -29871 0x11/imm32/alloc-id:fake -29872 _string-break-if-float<=/imm32/name -29873 0/imm32/no-inouts -29874 0/imm32/no-inouts -29875 0/imm32/no-outputs -29876 0/imm32/no-outputs -29877 0x11/imm32/alloc-id:fake -29878 _string_0f_86_jump_break/imm32/subx-name -29879 0/imm32/no-rm32 -29880 0/imm32/no-r32 -29881 0/imm32/no-imm32 -29882 0/imm32/no-imm8 -29883 0/imm32/no-disp32 -29884 0/imm32/no-xm32 -29885 0/imm32/no-x32 -29886 0x11/imm32/alloc-id:fake -29887 _Primitive-break-if-float>/imm32/next -29888 _Primitive-break-if-float>: # (payload primitive) -29889 0x11/imm32/alloc-id:fake:payload -29890 0x11/imm32/alloc-id:fake -29891 _string-break-if-float>/imm32/name -29892 0/imm32/no-inouts -29893 0/imm32/no-inouts -29894 0/imm32/no-outputs -29895 0/imm32/no-outputs +29868 _string_f3_0f_53_reciprocal/imm32/subx-name +29869 0/imm32/no-rm32 +29870 0/imm32/no-r32 +29871 0/imm32/no-imm32 +29872 0/imm32/no-imm8 +29873 0/imm32/no-disp32 +29874 1/imm32/xm32-is-first-inout +29875 3/imm32/x32-is-first-output +29876 0x11/imm32/alloc-id:fake +29877 _Primitive-reciprocal-mem-to-xreg/imm32/next +29878 _Primitive-reciprocal-mem-to-xreg: # (payload primitive) +29879 0x11/imm32/alloc-id:fake:payload +29880 # var1/xreg <- divide var2 => f3 0f 53/reciprocal var2/xm32 var1/x32 +29881 0x11/imm32/alloc-id:fake +29882 _string-reciprocal/imm32/name +29883 0x11/imm32/alloc-id:fake +29884 Single-float-var-in-mem/imm32/inouts +29885 0x11/imm32/alloc-id:fake +29886 Single-float-var-in-some-register/imm32/outputs +29887 0x11/imm32/alloc-id:fake +29888 _string_f3_0f_53_reciprocal/imm32/subx-name +29889 0/imm32/no-rm32 +29890 0/imm32/no-r32 +29891 0/imm32/no-imm32 +29892 0/imm32/no-imm8 +29893 0/imm32/no-disp32 +29894 1/imm32/xm32-is-first-inout +29895 3/imm32/x32-is-first-output 29896 0x11/imm32/alloc-id:fake -29897 _string_0f_87_jump_break/imm32/subx-name -29898 0/imm32/no-rm32 -29899 0/imm32/no-r32 -29900 0/imm32/no-imm32 -29901 0/imm32/no-imm8 -29902 0/imm32/no-disp32 -29903 0/imm32/no-xm32 -29904 0/imm32/no-x32 -29905 0x11/imm32/alloc-id:fake -29906 _Primitive-loop-if-float</imm32/next -29907 _Primitive-loop-if-float<: # (payload primitive) -29908 0x11/imm32/alloc-id:fake:payload -29909 0x11/imm32/alloc-id:fake -29910 _string-loop-if-float</imm32/name -29911 0/imm32/no-inouts -29912 0/imm32/no-inouts -29913 0/imm32/no-outputs -29914 0/imm32/no-outputs -29915 0x11/imm32/alloc-id:fake -29916 _string_0f_82_jump_loop/imm32/subx-name -29917 0/imm32/no-rm32 -29918 0/imm32/no-r32 -29919 0/imm32/no-imm32 -29920 0/imm32/no-imm8 -29921 0/imm32/no-disp32 -29922 0/imm32/no-xm32 -29923 0/imm32/no-x32 +29897 _Primitive-square-root-xreg-to-xreg/imm32/next +29898 # - floating-point square root +29899 _Primitive-square-root-xreg-to-xreg: # (payload primitive) +29900 0x11/imm32/alloc-id:fake:payload +29901 # var1/xreg <- square-root var2 => f3 0f 51/square-root var2/xm32 var1/x32 +29902 0x11/imm32/alloc-id:fake +29903 _string-square-root/imm32/name +29904 0x11/imm32/alloc-id:fake +29905 Single-float-var-in-some-register/imm32/inouts +29906 0x11/imm32/alloc-id:fake +29907 Single-float-var-in-some-register/imm32/outputs +29908 0x11/imm32/alloc-id:fake +29909 _string_f3_0f_51_square_root/imm32/subx-name +29910 0/imm32/no-rm32 +29911 0/imm32/no-r32 +29912 0/imm32/no-imm32 +29913 0/imm32/no-imm8 +29914 0/imm32/no-disp32 +29915 1/imm32/xm32-is-first-inout +29916 3/imm32/x32-is-first-output +29917 0x11/imm32/alloc-id:fake +29918 _Primitive-square-root-mem-to-xreg/imm32/next +29919 _Primitive-square-root-mem-to-xreg: # (payload primitive) +29920 0x11/imm32/alloc-id:fake:payload +29921 # var1/xreg <- divide var2 => f3 0f 51/square-root var2/xm32 var1/x32 +29922 0x11/imm32/alloc-id:fake +29923 _string-square-root/imm32/name 29924 0x11/imm32/alloc-id:fake -29925 _Primitive-loop-if-float>=/imm32/next -29926 _Primitive-loop-if-float>=: # (payload primitive) -29927 0x11/imm32/alloc-id:fake:payload +29925 Single-float-var-in-mem/imm32/inouts +29926 0x11/imm32/alloc-id:fake +29927 Single-float-var-in-some-register/imm32/outputs 29928 0x11/imm32/alloc-id:fake -29929 _string-loop-if-float>=/imm32/name -29930 0/imm32/no-inouts -29931 0/imm32/no-inouts -29932 0/imm32/no-outputs -29933 0/imm32/no-outputs -29934 0x11/imm32/alloc-id:fake -29935 _string_0f_83_jump_loop/imm32/subx-name -29936 0/imm32/no-rm32 -29937 0/imm32/no-r32 -29938 0/imm32/no-imm32 -29939 0/imm32/no-imm8 -29940 0/imm32/no-disp32 -29941 0/imm32/no-xm32 -29942 0/imm32/no-x32 +29929 _string_f3_0f_51_square_root/imm32/subx-name +29930 0/imm32/no-rm32 +29931 0/imm32/no-r32 +29932 0/imm32/no-imm32 +29933 0/imm32/no-imm8 +29934 0/imm32/no-disp32 +29935 1/imm32/xm32-is-first-inout +29936 3/imm32/x32-is-first-output +29937 0x11/imm32/alloc-id:fake +29938 _Primitive-inverse-square-root-xreg-to-xreg/imm32/next +29939 # - floating-point inverse square root 1/sqrt(x) +29940 _Primitive-inverse-square-root-xreg-to-xreg: # (payload primitive) +29941 0x11/imm32/alloc-id:fake:payload +29942 # var1/xreg <- reciprocal var2 => f3 0f 52/inverse-square-root var2/xm32 var1/x32 29943 0x11/imm32/alloc-id:fake -29944 _Primitive-loop-if-float<=/imm32/next -29945 _Primitive-loop-if-float<=: # (payload primitive) -29946 0x11/imm32/alloc-id:fake:payload +29944 _string-inverse-square-root/imm32/name +29945 0x11/imm32/alloc-id:fake +29946 Single-float-var-in-some-register/imm32/inouts 29947 0x11/imm32/alloc-id:fake -29948 _string-loop-if-float<=/imm32/name -29949 0/imm32/no-inouts -29950 0/imm32/no-inouts -29951 0/imm32/no-outputs -29952 0/imm32/no-outputs -29953 0x11/imm32/alloc-id:fake -29954 _string_0f_86_jump_loop/imm32/subx-name -29955 0/imm32/no-rm32 -29956 0/imm32/no-r32 -29957 0/imm32/no-imm32 -29958 0/imm32/no-imm8 -29959 0/imm32/no-disp32 -29960 0/imm32/no-xm32 -29961 0/imm32/no-x32 -29962 0x11/imm32/alloc-id:fake -29963 _Primitive-loop-if-float>/imm32/next -29964 _Primitive-loop-if-float>: # (payload primitive) -29965 0x11/imm32/alloc-id:fake:payload -29966 0x11/imm32/alloc-id:fake -29967 _string-loop-if-float>/imm32/name -29968 0/imm32/no-inouts -29969 0/imm32/no-inouts -29970 0/imm32/no-outputs -29971 0/imm32/no-outputs -29972 0x11/imm32/alloc-id:fake -29973 _string_0f_87_jump_loop/imm32/subx-name -29974 0/imm32/no-rm32 -29975 0/imm32/no-r32 -29976 0/imm32/no-imm32 -29977 0/imm32/no-imm8 -29978 0/imm32/no-disp32 -29979 0/imm32/no-xm32 -29980 0/imm32/no-x32 -29981 0x11/imm32/alloc-id:fake -29982 _Primitive-break-if-float<-named/imm32/next -29983 _Primitive-break-if-float<-named: # (payload primitive) -29984 0x11/imm32/alloc-id:fake:payload -29985 0x11/imm32/alloc-id:fake -29986 _string-break-if-float</imm32/name -29987 0x11/imm32/alloc-id:fake -29988 Single-lit-var/imm32/inouts +29948 Single-float-var-in-some-register/imm32/outputs +29949 0x11/imm32/alloc-id:fake +29950 _string_f3_0f_52_inverse_square_root/imm32/subx-name +29951 0/imm32/no-rm32 +29952 0/imm32/no-r32 +29953 0/imm32/no-imm32 +29954 0/imm32/no-imm8 +29955 0/imm32/no-disp32 +29956 1/imm32/xm32-is-first-inout +29957 3/imm32/x32-is-first-output +29958 0x11/imm32/alloc-id:fake +29959 _Primitive-inverse-square-root-mem-to-xreg/imm32/next +29960 _Primitive-inverse-square-root-mem-to-xreg: # (payload primitive) +29961 0x11/imm32/alloc-id:fake:payload +29962 # var1/xreg <- divide var2 => f3 0f 52/inverse-square-root var2/xm32 var1/x32 +29963 0x11/imm32/alloc-id:fake +29964 _string-inverse-square-root/imm32/name +29965 0x11/imm32/alloc-id:fake +29966 Single-float-var-in-mem/imm32/inouts +29967 0x11/imm32/alloc-id:fake +29968 Single-float-var-in-some-register/imm32/outputs +29969 0x11/imm32/alloc-id:fake +29970 _string_f3_0f_52_inverse_square_root/imm32/subx-name +29971 0/imm32/no-rm32 +29972 0/imm32/no-r32 +29973 0/imm32/no-imm32 +29974 0/imm32/no-imm8 +29975 0/imm32/no-disp32 +29976 1/imm32/xm32-is-first-inout +29977 3/imm32/x32-is-first-output +29978 0x11/imm32/alloc-id:fake +29979 _Primitive-compare-xreg-with-xreg/imm32/next +29980 # - floating-point compare +29981 _Primitive-compare-xreg-with-xreg: # (payload primitive) +29982 0x11/imm32/alloc-id:fake:payload +29983 # compare var1/reg1 var2/reg2 => 0f 2f/compare var2/x32 var1/xm32 +29984 0x11/imm32/alloc-id:fake +29985 _string-compare/imm32/name +29986 0x11/imm32/alloc-id:fake +29987 Two-float-args-in-regs/imm32/inouts +29988 0/imm32/no-outputs 29989 0/imm32/no-outputs -29990 0/imm32/no-outputs -29991 0x11/imm32/alloc-id:fake -29992 _string_0f_82_jump_label/imm32/subx-name -29993 0/imm32/no-rm32 -29994 0/imm32/no-r32 -29995 0/imm32/no-imm32 -29996 0/imm32/no-imm8 -29997 1/imm32/disp32-is-first-inout -29998 0/imm32/no-xm32 -29999 0/imm32/no-x32 -30000 0x11/imm32/alloc-id:fake -30001 _Primitive-break-if-float>=-named/imm32/next -30002 _Primitive-break-if-float>=-named: # (payload primitive) -30003 0x11/imm32/alloc-id:fake:payload +29990 0x11/imm32/alloc-id:fake +29991 _string_0f_2f_compare/imm32/subx-name +29992 0/imm32/no-rm32 +29993 0/imm32/no-r32 +29994 0/imm32/no-imm32 +29995 0/imm32/no-imm8 +29996 0/imm32/no-disp32 +29997 1/imm32/xm32-is-first-inout +29998 2/imm32/x32-is-second-inout +29999 0x11/imm32/alloc-id:fake +30000 _Primitive-compare-xreg-with-mem/imm32/next +30001 _Primitive-compare-xreg-with-mem: # (payload primitive) +30002 0x11/imm32/alloc-id:fake:payload +30003 # compare var1/xreg var2 => 0f 2f/compare var1/x32 var2/xm32 30004 0x11/imm32/alloc-id:fake -30005 _string-break-if-float>=/imm32/name +30005 _string-compare/imm32/name 30006 0x11/imm32/alloc-id:fake -30007 Single-lit-var/imm32/inouts +30007 Two-args-float-reg-float-stack/imm32/inouts 30008 0/imm32/no-outputs 30009 0/imm32/no-outputs 30010 0x11/imm32/alloc-id:fake -30011 _string_0f_83_jump_label/imm32/subx-name +30011 _string_0f_2f_compare/imm32/subx-name 30012 0/imm32/no-rm32 30013 0/imm32/no-r32 30014 0/imm32/no-imm32 30015 0/imm32/no-imm8 -30016 1/imm32/disp32-is-first-inout -30017 0/imm32/no-xm32 -30018 0/imm32/no-x32 +30016 0/imm32/no-disp32 +30017 2/imm32/xm32-is-second-inout +30018 1/imm32/x32-is-first-inout 30019 0x11/imm32/alloc-id:fake -30020 _Primitive-break-if-float<=-named/imm32/next -30021 _Primitive-break-if-float<=-named: # (payload primitive) -30022 0x11/imm32/alloc-id:fake:payload -30023 0x11/imm32/alloc-id:fake -30024 _string-break-if-float<=/imm32/name -30025 0x11/imm32/alloc-id:fake -30026 Single-lit-var/imm32/inouts -30027 0/imm32/no-outputs +30020 _Primitive-break-if-addr</imm32/next +30021 # - branches +30022 _Primitive-break-if-addr<: # (payload primitive) +30023 0x11/imm32/alloc-id:fake:payload +30024 0x11/imm32/alloc-id:fake +30025 _string-break-if-addr</imm32/name +30026 0/imm32/no-inouts +30027 0/imm32/no-inouts 30028 0/imm32/no-outputs -30029 0x11/imm32/alloc-id:fake -30030 _string_0f_86_jump_label/imm32/subx-name -30031 0/imm32/no-rm32 -30032 0/imm32/no-r32 -30033 0/imm32/no-imm32 -30034 0/imm32/no-imm8 -30035 1/imm32/disp32-is-first-inout -30036 0/imm32/no-xm32 -30037 0/imm32/no-x32 -30038 0x11/imm32/alloc-id:fake -30039 _Primitive-break-if-float>-named/imm32/next -30040 _Primitive-break-if-float>-named: # (payload primitive) -30041 0x11/imm32/alloc-id:fake:payload -30042 0x11/imm32/alloc-id:fake -30043 _string-break-if-float>/imm32/name -30044 0x11/imm32/alloc-id:fake -30045 Single-lit-var/imm32/inouts -30046 0/imm32/no-outputs +30029 0/imm32/no-outputs +30030 0x11/imm32/alloc-id:fake +30031 _string_0f_82_jump_break/imm32/subx-name +30032 0/imm32/no-rm32 +30033 0/imm32/no-r32 +30034 0/imm32/no-imm32 +30035 0/imm32/no-imm8 +30036 0/imm32/no-disp32 +30037 0/imm32/no-xm32 +30038 0/imm32/no-x32 +30039 0x11/imm32/alloc-id:fake +30040 _Primitive-break-if-addr>=/imm32/next +30041 _Primitive-break-if-addr>=: # (payload primitive) +30042 0x11/imm32/alloc-id:fake:payload +30043 0x11/imm32/alloc-id:fake +30044 _string-break-if-addr>=/imm32/name +30045 0/imm32/no-inouts +30046 0/imm32/no-inouts 30047 0/imm32/no-outputs -30048 0x11/imm32/alloc-id:fake -30049 _string_0f_87_jump_label/imm32/subx-name -30050 0/imm32/no-rm32 -30051 0/imm32/no-r32 -30052 0/imm32/no-imm32 -30053 0/imm32/no-imm8 -30054 1/imm32/disp32-is-first-inout -30055 0/imm32/no-xm32 -30056 0/imm32/no-x32 -30057 0x11/imm32/alloc-id:fake -30058 _Primitive-loop-if-float<-named/imm32/next -30059 _Primitive-loop-if-float<-named: # (payload primitive) -30060 0x11/imm32/alloc-id:fake:payload -30061 0x11/imm32/alloc-id:fake -30062 _string-loop-if-float</imm32/name -30063 0x11/imm32/alloc-id:fake -30064 Single-lit-var/imm32/inouts -30065 0/imm32/no-outputs +30048 0/imm32/no-outputs +30049 0x11/imm32/alloc-id:fake +30050 _string_0f_83_jump_break/imm32/subx-name +30051 0/imm32/no-rm32 +30052 0/imm32/no-r32 +30053 0/imm32/no-imm32 +30054 0/imm32/no-imm8 +30055 0/imm32/no-disp32 +30056 0/imm32/no-xm32 +30057 0/imm32/no-x32 +30058 0x11/imm32/alloc-id:fake +30059 _Primitive-break-if-=/imm32/next +30060 _Primitive-break-if-=: # (payload primitive) +30061 0x11/imm32/alloc-id:fake:payload +30062 0x11/imm32/alloc-id:fake +30063 _string-break-if-=/imm32/name +30064 0/imm32/no-inouts +30065 0/imm32/no-inouts 30066 0/imm32/no-outputs -30067 0x11/imm32/alloc-id:fake -30068 _string_0f_82_jump_label/imm32/subx-name -30069 0/imm32/no-rm32 -30070 0/imm32/no-r32 -30071 0/imm32/no-imm32 -30072 0/imm32/no-imm8 -30073 1/imm32/disp32-is-first-inout -30074 0/imm32/no-xm32 -30075 0/imm32/no-x32 -30076 0x11/imm32/alloc-id:fake -30077 _Primitive-loop-if-float>=-named/imm32/next -30078 _Primitive-loop-if-float>=-named: # (payload primitive) -30079 0x11/imm32/alloc-id:fake:payload -30080 0x11/imm32/alloc-id:fake -30081 _string-loop-if-float>=/imm32/name -30082 0x11/imm32/alloc-id:fake -30083 Single-lit-var/imm32/inouts -30084 0/imm32/no-outputs +30067 0/imm32/no-outputs +30068 0x11/imm32/alloc-id:fake +30069 _string_0f_84_jump_break/imm32/subx-name +30070 0/imm32/no-rm32 +30071 0/imm32/no-r32 +30072 0/imm32/no-imm32 +30073 0/imm32/no-imm8 +30074 0/imm32/no-disp32 +30075 0/imm32/no-xm32 +30076 0/imm32/no-x32 +30077 0x11/imm32/alloc-id:fake +30078 _Primitive-break-if-!=/imm32/next +30079 _Primitive-break-if-!=: # (payload primitive) +30080 0x11/imm32/alloc-id:fake:payload +30081 0x11/imm32/alloc-id:fake +30082 _string-break-if-!=/imm32/name +30083 0/imm32/no-inouts +30084 0/imm32/no-inouts 30085 0/imm32/no-outputs -30086 0x11/imm32/alloc-id:fake -30087 _string_0f_83_jump_label/imm32/subx-name -30088 0/imm32/no-rm32 -30089 0/imm32/no-r32 -30090 0/imm32/no-imm32 -30091 0/imm32/no-imm8 -30092 1/imm32/disp32-is-first-inout -30093 0/imm32/no-xm32 -30094 0/imm32/no-x32 -30095 0x11/imm32/alloc-id:fake -30096 _Primitive-loop-if-float<=-named/imm32/next -30097 _Primitive-loop-if-float<=-named: # (payload primitive) -30098 0x11/imm32/alloc-id:fake:payload -30099 0x11/imm32/alloc-id:fake -30100 _string-loop-if-float<=/imm32/name -30101 0x11/imm32/alloc-id:fake -30102 Single-lit-var/imm32/inouts -30103 0/imm32/no-outputs +30086 0/imm32/no-outputs +30087 0x11/imm32/alloc-id:fake +30088 _string_0f_85_jump_break/imm32/subx-name +30089 0/imm32/no-rm32 +30090 0/imm32/no-r32 +30091 0/imm32/no-imm32 +30092 0/imm32/no-imm8 +30093 0/imm32/no-disp32 +30094 0/imm32/no-xm32 +30095 0/imm32/no-x32 +30096 0x11/imm32/alloc-id:fake +30097 _Primitive-break-if-addr<=/imm32/next +30098 _Primitive-break-if-addr<=: # (payload primitive) +30099 0x11/imm32/alloc-id:fake:payload +30100 0x11/imm32/alloc-id:fake +30101 _string-break-if-addr<=/imm32/name +30102 0/imm32/no-inouts +30103 0/imm32/no-inouts 30104 0/imm32/no-outputs -30105 0x11/imm32/alloc-id:fake -30106 _string_0f_86_jump_label/imm32/subx-name -30107 0/imm32/no-rm32 -30108 0/imm32/no-r32 -30109 0/imm32/no-imm32 -30110 0/imm32/no-imm8 -30111 1/imm32/disp32-is-first-inout -30112 0/imm32/no-xm32 -30113 0/imm32/no-x32 -30114 0x11/imm32/alloc-id:fake -30115 _Primitive-loop-if-float>-named/imm32/next -30116 _Primitive-loop-if-float>-named: # (payload primitive) -30117 0x11/imm32/alloc-id:fake:payload -30118 0x11/imm32/alloc-id:fake -30119 _string-loop-if-float>/imm32/name -30120 0x11/imm32/alloc-id:fake -30121 Single-lit-var/imm32/inouts -30122 0/imm32/no-outputs +30105 0/imm32/no-outputs +30106 0x11/imm32/alloc-id:fake +30107 _string_0f_86_jump_break/imm32/subx-name +30108 0/imm32/no-rm32 +30109 0/imm32/no-r32 +30110 0/imm32/no-imm32 +30111 0/imm32/no-imm8 +30112 0/imm32/no-disp32 +30113 0/imm32/no-xm32 +30114 0/imm32/no-x32 +30115 0x11/imm32/alloc-id:fake +30116 _Primitive-break-if-addr>/imm32/next +30117 _Primitive-break-if-addr>: # (payload primitive) +30118 0x11/imm32/alloc-id:fake:payload +30119 0x11/imm32/alloc-id:fake +30120 _string-break-if-addr>/imm32/name +30121 0/imm32/no-inouts +30122 0/imm32/no-inouts 30123 0/imm32/no-outputs -30124 0x11/imm32/alloc-id:fake -30125 _string_0f_87_jump_label/imm32/subx-name -30126 0/imm32/no-rm32 -30127 0/imm32/no-r32 -30128 0/imm32/no-imm32 -30129 0/imm32/no-imm8 -30130 1/imm32/disp32-is-first-inout -30131 0/imm32/no-xm32 -30132 0/imm32/no-x32 -30133 0/imm32/next -30134 0/imm32/next -30135 -30136 # string literals for Mu instructions -30137 _string-add: # (payload array byte) -30138 0x11/imm32/alloc-id:fake:payload -30139 # "add" -30140 0x3/imm32/size -30141 0x61/a 0x64/d 0x64/d -30142 _string-address: # (payload array byte) -30143 0x11/imm32/alloc-id:fake:payload -30144 # "address" -30145 0x7/imm32/size -30146 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s -30147 _string-add-to: # (payload array byte) -30148 0x11/imm32/alloc-id:fake:payload -30149 # "add-to" -30150 0x6/imm32/size -30151 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o -30152 _string-and: # (payload array byte) -30153 0x11/imm32/alloc-id:fake:payload -30154 # "and" -30155 0x3/imm32/size -30156 0x61/a 0x6e/n 0x64/d -30157 _string-and-with: # (payload array byte) -30158 0x11/imm32/alloc-id:fake:payload -30159 # "and-with" -30160 0x8/imm32/size -30161 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -30162 _string-break: # (payload array byte) -30163 0x11/imm32/alloc-id:fake:payload -30164 # "break" -30165 0x5/imm32/size -30166 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k -30167 _string-break-if-<: # (payload array byte) -30168 0x11/imm32/alloc-id:fake:payload -30169 # "break-if-<" -30170 0xa/imm32/size -30171 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< -30172 _string-break-if-<=: # (payload array byte) -30173 0x11/imm32/alloc-id:fake:payload -30174 # "break-if-<=" -30175 0xb/imm32/size -30176 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= -30177 _string-break-if-=: # (payload array byte) -30178 0x11/imm32/alloc-id:fake:payload -30179 # "break-if-=" -30180 0xa/imm32/size -30181 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= -30182 _string-break-if->: # (payload array byte) -30183 0x11/imm32/alloc-id:fake:payload -30184 # "break-if->" -30185 0xa/imm32/size -30186 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> -30187 _string-break-if->=: # (payload array byte) -30188 0x11/imm32/alloc-id:fake:payload -30189 # "break-if->=" -30190 0xb/imm32/size -30191 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= -30192 _string-break-if-!=: # (payload array byte) -30193 0x11/imm32/alloc-id:fake:payload -30194 # "break-if-!=" -30195 0xb/imm32/size -30196 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= -30197 _string-break-if-addr<: # (payload array byte) -30198 0x11/imm32/alloc-id:fake:payload -30199 # "break-if-addr<" -30200 0xe/imm32/size -30201 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/< -30202 _string-break-if-addr<=: # (payload array byte) -30203 0x11/imm32/alloc-id:fake:payload -30204 # "break-if-addr<=" -30205 0xf/imm32/size -30206 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/= -30207 _string-break-if-addr>: # (payload array byte) -30208 0x11/imm32/alloc-id:fake:payload -30209 # "break-if-addr>" -30210 0xe/imm32/size -30211 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/> -30212 _string-break-if-addr>=: # (payload array byte) +30124 0/imm32/no-outputs +30125 0x11/imm32/alloc-id:fake +30126 _string_0f_87_jump_break/imm32/subx-name +30127 0/imm32/no-rm32 +30128 0/imm32/no-r32 +30129 0/imm32/no-imm32 +30130 0/imm32/no-imm8 +30131 0/imm32/no-disp32 +30132 0/imm32/no-xm32 +30133 0/imm32/no-x32 +30134 0x11/imm32/alloc-id:fake +30135 _Primitive-break-if-</imm32/next +30136 _Primitive-break-if-<: # (payload primitive) +30137 0x11/imm32/alloc-id:fake:payload +30138 0x11/imm32/alloc-id:fake +30139 _string-break-if-</imm32/name +30140 0/imm32/no-inouts +30141 0/imm32/no-inouts +30142 0/imm32/no-outputs +30143 0/imm32/no-outputs +30144 0x11/imm32/alloc-id:fake +30145 _string_0f_8c_jump_break/imm32/subx-name +30146 0/imm32/no-rm32 +30147 0/imm32/no-r32 +30148 0/imm32/no-imm32 +30149 0/imm32/no-imm8 +30150 0/imm32/no-disp32 +30151 0/imm32/no-xm32 +30152 0/imm32/no-x32 +30153 0x11/imm32/alloc-id:fake +30154 _Primitive-break-if->=/imm32/next +30155 _Primitive-break-if->=: # (payload primitive) +30156 0x11/imm32/alloc-id:fake:payload +30157 0x11/imm32/alloc-id:fake +30158 _string-break-if->=/imm32/name +30159 0/imm32/no-inouts +30160 0/imm32/no-inouts +30161 0/imm32/no-outputs +30162 0/imm32/no-outputs +30163 0x11/imm32/alloc-id:fake +30164 _string_0f_8d_jump_break/imm32/subx-name +30165 0/imm32/no-rm32 +30166 0/imm32/no-r32 +30167 0/imm32/no-imm32 +30168 0/imm32/no-imm8 +30169 0/imm32/no-disp32 +30170 0/imm32/no-xm32 +30171 0/imm32/no-x32 +30172 0x11/imm32/alloc-id:fake +30173 _Primitive-break-if-<=/imm32/next +30174 _Primitive-break-if-<=: # (payload primitive) +30175 0x11/imm32/alloc-id:fake:payload +30176 0x11/imm32/alloc-id:fake +30177 _string-break-if-<=/imm32/name +30178 0/imm32/no-inouts +30179 0/imm32/no-inouts +30180 0/imm32/no-outputs +30181 0/imm32/no-outputs +30182 0x11/imm32/alloc-id:fake +30183 _string_0f_8e_jump_break/imm32/subx-name +30184 0/imm32/no-rm32 +30185 0/imm32/no-r32 +30186 0/imm32/no-imm32 +30187 0/imm32/no-imm8 +30188 0/imm32/no-disp32 +30189 0/imm32/no-xm32 +30190 0/imm32/no-x32 +30191 0x11/imm32/alloc-id:fake +30192 _Primitive-break-if->/imm32/next +30193 _Primitive-break-if->: # (payload primitive) +30194 0x11/imm32/alloc-id:fake:payload +30195 0x11/imm32/alloc-id:fake +30196 _string-break-if->/imm32/name +30197 0/imm32/no-inouts +30198 0/imm32/no-inouts +30199 0/imm32/no-outputs +30200 0/imm32/no-outputs +30201 0x11/imm32/alloc-id:fake +30202 _string_0f_8f_jump_break/imm32/subx-name +30203 0/imm32/no-rm32 +30204 0/imm32/no-r32 +30205 0/imm32/no-imm32 +30206 0/imm32/no-imm8 +30207 0/imm32/no-disp32 +30208 0/imm32/no-xm32 +30209 0/imm32/no-x32 +30210 0x11/imm32/alloc-id:fake +30211 _Primitive-break/imm32/next +30212 _Primitive-break: # (payload primitive) 30213 0x11/imm32/alloc-id:fake:payload -30214 # "break-if-addr>=" -30215 0xf/imm32/size -30216 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/= -30217 _string-break-if-float<: # (payload array byte) -30218 0x11/imm32/alloc-id:fake:payload -30219 # "break-if-float<" -30220 0xf/imm32/size -30221 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< -30222 _string-break-if-float<=: # (payload array byte) -30223 0x11/imm32/alloc-id:fake:payload -30224 # "break-if-float<=" -30225 0x10/imm32/size -30226 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< 0x3d/= -30227 _string-break-if-float>: # (payload array byte) -30228 0x11/imm32/alloc-id:fake:payload -30229 # "break-if-float>" -30230 0xf/imm32/size -30231 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> -30232 _string-break-if-float>=: # (payload array byte) -30233 0x11/imm32/alloc-id:fake:payload -30234 # "break-if-float>=" -30235 0x10/imm32/size -30236 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> 0x3d/= -30237 _string-compare: # (payload array byte) -30238 0x11/imm32/alloc-id:fake:payload -30239 # "compare" -30240 0x7/imm32/size -30241 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e -30242 _string-copy: # (payload array byte) -30243 0x11/imm32/alloc-id:fake:payload -30244 # "copy" -30245 0x4/imm32/size -30246 0x63/c 0x6f/o 0x70/p 0x79/y -30247 _string-copy-to: # (payload array byte) -30248 0x11/imm32/alloc-id:fake:payload -30249 # "copy-to" -30250 0x7/imm32/size -30251 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o -30252 _string-copy-byte: -30253 0x11/imm32/alloc-id:fake:payload -30254 # "copy-byte" -30255 0x9/imm32/size -30256 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e -30257 _string-copy-byte-to: -30258 0x11/imm32/alloc-id:fake:payload -30259 # "copy-byte-to" -30260 0xc/imm32/size -30261 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x74/t 0x6f/o -30262 _string-decrement: # (payload array byte) -30263 0x11/imm32/alloc-id:fake:payload -30264 # "decrement" -30265 0x9/imm32/size -30266 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t -30267 _string-increment: # (payload array byte) -30268 0x11/imm32/alloc-id:fake:payload -30269 # "increment" -30270 0x9/imm32/size -30271 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t -30272 _string-loop: # (payload array byte) -30273 0x11/imm32/alloc-id:fake:payload -30274 # "loop" -30275 0x4/imm32/size -30276 0x6c/l 0x6f/o 0x6f/o 0x70/p -30277 _string-loop-if-<: # (payload array byte) -30278 0x11/imm32/alloc-id:fake:payload -30279 # "loop-if-<" -30280 0x9/imm32/size -30281 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< -30282 _string-loop-if-<=: # (payload array byte) -30283 0x11/imm32/alloc-id:fake:payload -30284 # "loop-if-<=" -30285 0xa/imm32/size -30286 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= -30287 _string-loop-if-=: # (payload array byte) -30288 0x11/imm32/alloc-id:fake:payload -30289 # "loop-if-=" -30290 0x9/imm32/size -30291 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= -30292 _string-loop-if->: # (payload array byte) -30293 0x11/imm32/alloc-id:fake:payload -30294 # "loop-if->" -30295 0x9/imm32/size -30296 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> -30297 _string-loop-if->=: # (payload array byte) -30298 0x11/imm32/alloc-id:fake:payload -30299 # "loop-if->=" -30300 0xa/imm32/size -30301 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= -30302 _string-loop-if-!=: # (payload array byte) -30303 0x11/imm32/alloc-id:fake:payload -30304 # "loop-if-!=" -30305 0xa/imm32/size -30306 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= -30307 _string-loop-if-addr<: # (payload array byte) +30214 0x11/imm32/alloc-id:fake +30215 _string-break/imm32/name +30216 0/imm32/no-inouts +30217 0/imm32/no-inouts +30218 0/imm32/no-outputs +30219 0/imm32/no-outputs +30220 0x11/imm32/alloc-id:fake +30221 _string_e9_jump_break/imm32/subx-name +30222 0/imm32/no-rm32 +30223 0/imm32/no-r32 +30224 0/imm32/no-imm32 +30225 0/imm32/no-imm8 +30226 0/imm32/no-disp32 +30227 0/imm32/no-xm32 +30228 0/imm32/no-x32 +30229 0x11/imm32/alloc-id:fake +30230 _Primitive-loop-if-addr</imm32/next +30231 _Primitive-loop-if-addr<: # (payload primitive) +30232 0x11/imm32/alloc-id:fake:payload +30233 0x11/imm32/alloc-id:fake +30234 _string-loop-if-addr</imm32/name +30235 0/imm32/no-inouts +30236 0/imm32/no-inouts +30237 0/imm32/no-outputs +30238 0/imm32/no-outputs +30239 0x11/imm32/alloc-id:fake +30240 _string_0f_82_jump_loop/imm32/subx-name +30241 0/imm32/no-rm32 +30242 0/imm32/no-r32 +30243 0/imm32/no-imm32 +30244 0/imm32/no-imm8 +30245 0/imm32/no-disp32 +30246 0/imm32/no-xm32 +30247 0/imm32/no-x32 +30248 0x11/imm32/alloc-id:fake +30249 _Primitive-loop-if-addr>=/imm32/next +30250 _Primitive-loop-if-addr>=: # (payload primitive) +30251 0x11/imm32/alloc-id:fake:payload +30252 0x11/imm32/alloc-id:fake +30253 _string-loop-if-addr>=/imm32/name +30254 0/imm32/no-inouts +30255 0/imm32/no-inouts +30256 0/imm32/no-outputs +30257 0/imm32/no-outputs +30258 0x11/imm32/alloc-id:fake +30259 _string_0f_83_jump_loop/imm32/subx-name +30260 0/imm32/no-rm32 +30261 0/imm32/no-r32 +30262 0/imm32/no-imm32 +30263 0/imm32/no-imm8 +30264 0/imm32/no-disp32 +30265 0/imm32/no-xm32 +30266 0/imm32/no-x32 +30267 0x11/imm32/alloc-id:fake +30268 _Primitive-loop-if-=/imm32/next +30269 _Primitive-loop-if-=: # (payload primitive) +30270 0x11/imm32/alloc-id:fake:payload +30271 0x11/imm32/alloc-id:fake +30272 _string-loop-if-=/imm32/name +30273 0/imm32/no-inouts +30274 0/imm32/no-inouts +30275 0/imm32/no-outputs +30276 0/imm32/no-outputs +30277 0x11/imm32/alloc-id:fake +30278 _string_0f_84_jump_loop/imm32/subx-name +30279 0/imm32/no-rm32 +30280 0/imm32/no-r32 +30281 0/imm32/no-imm32 +30282 0/imm32/no-imm8 +30283 0/imm32/no-disp32 +30284 0/imm32/no-xm32 +30285 0/imm32/no-x32 +30286 0x11/imm32/alloc-id:fake +30287 _Primitive-loop-if-!=/imm32/next +30288 _Primitive-loop-if-!=: # (payload primitive) +30289 0x11/imm32/alloc-id:fake:payload +30290 0x11/imm32/alloc-id:fake +30291 _string-loop-if-!=/imm32/name +30292 0/imm32/no-inouts +30293 0/imm32/no-inouts +30294 0/imm32/no-outputs +30295 0/imm32/no-outputs +30296 0x11/imm32/alloc-id:fake +30297 _string_0f_85_jump_loop/imm32/subx-name +30298 0/imm32/no-rm32 +30299 0/imm32/no-r32 +30300 0/imm32/no-imm32 +30301 0/imm32/no-imm8 +30302 0/imm32/no-disp32 +30303 0/imm32/no-xm32 +30304 0/imm32/no-x32 +30305 0x11/imm32/alloc-id:fake +30306 _Primitive-loop-if-addr<=/imm32/next +30307 _Primitive-loop-if-addr<=: # (payload primitive) 30308 0x11/imm32/alloc-id:fake:payload -30309 # "loop-if-addr<" -30310 0xd/imm32/size -30311 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/< -30312 _string-loop-if-addr<=: # (payload array byte) -30313 0x11/imm32/alloc-id:fake:payload -30314 # "loop-if-addr<=" -30315 0xe/imm32/size -30316 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/= -30317 _string-loop-if-addr>: # (payload array byte) -30318 0x11/imm32/alloc-id:fake:payload -30319 # "loop-if-addr>" -30320 0xd/imm32/size -30321 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/> -30322 _string-loop-if-addr>=: # (payload array byte) -30323 0x11/imm32/alloc-id:fake:payload -30324 # "loop-if-addr>=" -30325 0xe/imm32/size -30326 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/= -30327 _string-loop-if-float<: # (payload array byte) -30328 0x11/imm32/alloc-id:fake:payload -30329 # "loop-if-float<" -30330 0xe/imm32/size -30331 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< -30332 _string-loop-if-float<=: # (payload array byte) -30333 0x11/imm32/alloc-id:fake:payload -30334 # "loop-if-float<=" -30335 0xf/imm32/size -30336 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< 0x3d/= -30337 _string-loop-if-float>: # (payload array byte) -30338 0x11/imm32/alloc-id:fake:payload -30339 # "loop-if-float>" -30340 0xe/imm32/size -30341 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> -30342 _string-loop-if-float>=: # (payload array byte) -30343 0x11/imm32/alloc-id:fake:payload -30344 # "loop-if-float>=" -30345 0xf/imm32/size -30346 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> 0x3d/= -30347 _string-multiply: # (payload array byte) -30348 0x11/imm32/alloc-id:fake:payload -30349 # "multiply" -30350 0x8/imm32/size -30351 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y -30352 _string-convert: # (payload array byte) -30353 0x11/imm32/alloc-id:fake:payload -30354 # "convert" -30355 0x7/imm32/size -30356 0x63/c 0x6f/o 0x6e/n 0x76/v 0x65/e 0x72/r 0x74/t -30357 _string-truncate: # (payload array byte) -30358 0x11/imm32/alloc-id:fake:payload -30359 # "truncate" -30360 0x8/imm32/size -30361 0x74/t 0x72/r 0x75/u 0x6e/n 0x63/c 0x61/a 0x74/t 0x65/e -30362 _string-reinterpret: # (payload array byte) -30363 0x11/imm32/alloc-id:fake:payload -30364 # "reinterpret" -30365 0xb/imm32/size -30366 0x72/r 0x65/e 0x69/i 0x6e/n 0x74/t 0x65/e 0x72/r 0x70/p 0x72/r 0x65/e 0x74/t -30367 _string-divide: -30368 0x11/imm32/alloc-id:fake:payload -30369 # "divide" -30370 0x6/imm32/size -30371 0x64/d 0x69/i 0x76/v 0x69/i 0x64/d 0x65/e -30372 _string-max: -30373 0x11/imm32/alloc-id:fake:payload -30374 # "max" -30375 0x3/imm32/size -30376 0x6d/m 0x61/a 0x78/x -30377 _string-min: -30378 0x11/imm32/alloc-id:fake:payload -30379 # "min" -30380 0x3/imm32/size -30381 0x6d/m 0x69/i 0x6e/n -30382 _string-reciprocal: -30383 0x11/imm32/alloc-id:fake:payload -30384 # "reciprocal" -30385 0xa/imm32/size -30386 0x72/r 0x65/e 0x63/c 0x69/i 0x70/p 0x72/r 0x6f/o 0x63/c 0x61/a 0x6c/l -30387 _string-square-root: -30388 0x11/imm32/alloc-id:fake:payload -30389 # "square-root" -30390 0xb/imm32/size -30391 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/- 0x72/r 0x6f/o 0x6f/o 0x74/t -30392 _string-inverse-square-root: -30393 0x11/imm32/alloc-id:fake:payload -30394 # "inverse-square-root" -30395 0x13/imm32/size -30396 0x69/i 0x6e/n 0x76/v 0x65/e 0x72/r 0x73/s 0x65/e 0x2d/- 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/- 0x72/r 0x6f/o 0x6f/o 0x74/t -30397 _string-negate: # (payload array byte) -30398 0x11/imm32/alloc-id:fake:payload -30399 # "negate" -30400 0x6/imm32/size -30401 0x6e/n 0x65/e 0x67/g 0x61/a 0x74/t 0x65/e -30402 _string-or: # (payload array byte) +30309 0x11/imm32/alloc-id:fake +30310 _string-loop-if-addr<=/imm32/name +30311 0/imm32/no-inouts +30312 0/imm32/no-inouts +30313 0/imm32/no-outputs +30314 0/imm32/no-outputs +30315 0x11/imm32/alloc-id:fake +30316 _string_0f_86_jump_loop/imm32/subx-name +30317 0/imm32/no-rm32 +30318 0/imm32/no-r32 +30319 0/imm32/no-imm32 +30320 0/imm32/no-imm8 +30321 0/imm32/no-disp32 +30322 0/imm32/no-xm32 +30323 0/imm32/no-x32 +30324 0x11/imm32/alloc-id:fake +30325 _Primitive-loop-if-addr>/imm32/next +30326 _Primitive-loop-if-addr>: # (payload primitive) +30327 0x11/imm32/alloc-id:fake:payload +30328 0x11/imm32/alloc-id:fake +30329 _string-loop-if-addr>/imm32/name +30330 0/imm32/no-inouts +30331 0/imm32/no-inouts +30332 0/imm32/no-outputs +30333 0/imm32/no-outputs +30334 0x11/imm32/alloc-id:fake +30335 _string_0f_87_jump_loop/imm32/subx-name +30336 0/imm32/no-rm32 +30337 0/imm32/no-r32 +30338 0/imm32/no-imm32 +30339 0/imm32/no-imm8 +30340 0/imm32/no-disp32 +30341 0/imm32/no-xm32 +30342 0/imm32/no-x32 +30343 0x11/imm32/alloc-id:fake +30344 _Primitive-loop-if-</imm32/next +30345 _Primitive-loop-if-<: # (payload primitive) +30346 0x11/imm32/alloc-id:fake:payload +30347 0x11/imm32/alloc-id:fake +30348 _string-loop-if-</imm32/name +30349 0/imm32/no-inouts +30350 0/imm32/no-inouts +30351 0/imm32/no-outputs +30352 0/imm32/no-outputs +30353 0x11/imm32/alloc-id:fake +30354 _string_0f_8c_jump_loop/imm32/subx-name +30355 0/imm32/no-rm32 +30356 0/imm32/no-r32 +30357 0/imm32/no-imm32 +30358 0/imm32/no-imm8 +30359 0/imm32/no-disp32 +30360 0/imm32/no-xm32 +30361 0/imm32/no-x32 +30362 0x11/imm32/alloc-id:fake +30363 _Primitive-loop-if->=/imm32/next +30364 _Primitive-loop-if->=: # (payload primitive) +30365 0x11/imm32/alloc-id:fake:payload +30366 0x11/imm32/alloc-id:fake +30367 _string-loop-if->=/imm32/name +30368 0/imm32/no-inouts +30369 0/imm32/no-inouts +30370 0/imm32/no-outputs +30371 0/imm32/no-outputs +30372 0x11/imm32/alloc-id:fake +30373 _string_0f_8d_jump_loop/imm32/subx-name +30374 0/imm32/no-rm32 +30375 0/imm32/no-r32 +30376 0/imm32/no-imm32 +30377 0/imm32/no-imm8 +30378 0/imm32/no-disp32 +30379 0/imm32/no-xm32 +30380 0/imm32/no-x32 +30381 0x11/imm32/alloc-id:fake +30382 _Primitive-loop-if-<=/imm32/next +30383 _Primitive-loop-if-<=: # (payload primitive) +30384 0x11/imm32/alloc-id:fake:payload +30385 0x11/imm32/alloc-id:fake +30386 _string-loop-if-<=/imm32/name +30387 0/imm32/no-inouts +30388 0/imm32/no-inouts +30389 0/imm32/no-outputs +30390 0/imm32/no-outputs +30391 0x11/imm32/alloc-id:fake +30392 _string_0f_8e_jump_loop/imm32/subx-name +30393 0/imm32/no-rm32 +30394 0/imm32/no-r32 +30395 0/imm32/no-imm32 +30396 0/imm32/no-imm8 +30397 0/imm32/no-disp32 +30398 0/imm32/no-xm32 +30399 0/imm32/no-x32 +30400 0x11/imm32/alloc-id:fake +30401 _Primitive-loop-if->/imm32/next +30402 _Primitive-loop-if->: # (payload primitive) 30403 0x11/imm32/alloc-id:fake:payload -30404 # "or" -30405 0x2/imm32/size -30406 0x6f/o 0x72/r -30407 _string-or-with: # (payload array byte) -30408 0x11/imm32/alloc-id:fake:payload -30409 # "or-with" -30410 0x7/imm32/size -30411 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -30412 _string-subtract: # (payload array byte) -30413 0x11/imm32/alloc-id:fake:payload -30414 # "subtract" -30415 0x8/imm32/size -30416 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t -30417 _string-subtract-from: # (payload array byte) -30418 0x11/imm32/alloc-id:fake:payload -30419 # "subtract-from" -30420 0xd/imm32/size -30421 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 -30422 _string-xor: # (payload array byte) -30423 0x11/imm32/alloc-id:fake:payload -30424 # "xor" -30425 0x3/imm32/size -30426 0x78/x 0x6f/o 0x72/r -30427 _string-xor-with: # (payload array byte) -30428 0x11/imm32/alloc-id:fake:payload -30429 # "xor-with" -30430 0x8/imm32/size -30431 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -30432 _string-shift-left: # (payload array byte) -30433 0x11/imm32/alloc-id:fake:payload -30434 # "shift-left" -30435 0xa/imm32/size -30436 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x6c/l 0x65/e 0x66/f 0x74/t -30437 _string-shift-right: # (payload array byte) -30438 0x11/imm32/alloc-id:fake:payload -30439 # "shift-right" -30440 0xb/imm32/size -30441 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t -30442 _string-shift-right-signed: # (payload array byte) -30443 0x11/imm32/alloc-id:fake:payload -30444 # "shift-right-signed" -30445 0x12/imm32/size -30446 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n 0x65/e 0x64/d -30447 -30448 # string literals for SubX instructions -30449 _string_01_add_to: # (payload array byte) -30450 0x11/imm32/alloc-id:fake:payload -30451 # "01/add-to" -30452 0x9/imm32/size -30453 0x30/0 0x31/1 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o -30454 _string_03_add: # (payload array byte) -30455 0x11/imm32/alloc-id:fake:payload -30456 # "03/add" -30457 0x6/imm32/size -30458 0x30/0 0x33/3 0x2f/slash 0x61/a 0x64/d 0x64/d -30459 _string_05_add_to_eax: # (payload array byte) -30460 0x11/imm32/alloc-id:fake:payload -30461 # "05/add-to-eax" -30462 0xd/imm32/size -30463 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 -30464 _string_09_or_with: # (payload array byte) -30465 0x11/imm32/alloc-id:fake:payload -30466 # "09/or-with" -30467 0xa/imm32/size -30468 0x30/0 0x39/9 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -30469 _string_0b_or: # (payload array byte) -30470 0x11/imm32/alloc-id:fake:payload -30471 # "0b/or" -30472 0x5/imm32/size -30473 0x30/0 0x62/b 0x2f/slash 0x6f/o 0x72/r -30474 _string_0d_or_with_eax: # (payload array byte) -30475 0x11/imm32/alloc-id:fake:payload -30476 # "0d/or-with-eax" -30477 0xe/imm32/size -30478 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 -30479 _string_0f_82_jump_label: # (payload array byte) +30404 0x11/imm32/alloc-id:fake +30405 _string-loop-if->/imm32/name +30406 0/imm32/no-inouts +30407 0/imm32/no-inouts +30408 0/imm32/no-outputs +30409 0/imm32/no-outputs +30410 0x11/imm32/alloc-id:fake +30411 _string_0f_8f_jump_loop/imm32/subx-name +30412 0/imm32/no-rm32 +30413 0/imm32/no-r32 +30414 0/imm32/no-imm32 +30415 0/imm32/no-imm8 +30416 0/imm32/no-disp32 +30417 0/imm32/no-xm32 +30418 0/imm32/no-x32 +30419 0x11/imm32/alloc-id:fake +30420 _Primitive-loop/imm32/next # we probably don't need an unconditional break +30421 _Primitive-loop: # (payload primitive) +30422 0x11/imm32/alloc-id:fake:payload +30423 0x11/imm32/alloc-id:fake +30424 _string-loop/imm32/name +30425 0/imm32/no-inouts +30426 0/imm32/no-inouts +30427 0/imm32/no-outputs +30428 0/imm32/no-outputs +30429 0x11/imm32/alloc-id:fake +30430 _string_e9_jump_loop/imm32/subx-name +30431 0/imm32/no-rm32 +30432 0/imm32/no-r32 +30433 0/imm32/no-imm32 +30434 0/imm32/no-imm8 +30435 0/imm32/no-disp32 +30436 0/imm32/no-xm32 +30437 0/imm32/no-x32 +30438 0x11/imm32/alloc-id:fake +30439 _Primitive-break-if-addr<-named/imm32/next +30440 # - branches to named blocks +30441 _Primitive-break-if-addr<-named: # (payload primitive) +30442 0x11/imm32/alloc-id:fake:payload +30443 0x11/imm32/alloc-id:fake +30444 _string-break-if-addr</imm32/name +30445 0x11/imm32/alloc-id:fake +30446 Single-lit-var/imm32/inouts +30447 0/imm32/no-outputs +30448 0/imm32/no-outputs +30449 0x11/imm32/alloc-id:fake +30450 _string_0f_82_jump_label/imm32/subx-name +30451 0/imm32/no-rm32 +30452 0/imm32/no-r32 +30453 0/imm32/no-imm32 +30454 0/imm32/no-imm8 +30455 1/imm32/disp32-is-first-inout +30456 0/imm32/no-xm32 +30457 0/imm32/no-x32 +30458 0x11/imm32/alloc-id:fake +30459 _Primitive-break-if-addr>=-named/imm32/next +30460 _Primitive-break-if-addr>=-named: # (payload primitive) +30461 0x11/imm32/alloc-id:fake:payload +30462 0x11/imm32/alloc-id:fake +30463 _string-break-if-addr>=/imm32/name +30464 0x11/imm32/alloc-id:fake +30465 Single-lit-var/imm32/inouts +30466 0/imm32/no-outputs +30467 0/imm32/no-outputs +30468 0x11/imm32/alloc-id:fake +30469 _string_0f_83_jump_label/imm32/subx-name +30470 0/imm32/no-rm32 +30471 0/imm32/no-r32 +30472 0/imm32/no-imm32 +30473 0/imm32/no-imm8 +30474 1/imm32/disp32-is-first-inout +30475 0/imm32/no-xm32 +30476 0/imm32/no-x32 +30477 0x11/imm32/alloc-id:fake +30478 _Primitive-break-if-=-named/imm32/next +30479 _Primitive-break-if-=-named: # (payload primitive) 30480 0x11/imm32/alloc-id:fake:payload -30481 # "0f 82/jump-if-addr<" -30482 0x13/imm32/size -30483 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/< -30484 _string_0f_82_jump_break: # (payload array byte) -30485 0x11/imm32/alloc-id:fake:payload -30486 # "0f 82/jump-if-addr< break/disp32" -30487 0x20/imm32/size -30488 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 -30489 _string_0f_82_jump_loop: # (payload array byte) -30490 0x11/imm32/alloc-id:fake:payload -30491 # "0f 82/jump-if-addr< loop/disp32" -30492 0x1f/imm32/size -30493 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 -30494 _string_0f_83_jump_label: # (payload array byte) -30495 0x11/imm32/alloc-id:fake:payload -30496 # "0f 83/jump-if-addr>=" -30497 0x14/imm32/size -30498 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/= -30499 _string_0f_83_jump_break: # (payload array byte) -30500 0x11/imm32/alloc-id:fake:payload -30501 # "0f 83/jump-if-addr>= break/disp32" -30502 0x21/imm32/size -30503 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 -30504 _string_0f_83_jump_loop: # (payload array byte) -30505 0x11/imm32/alloc-id:fake:payload -30506 # "0f 83/jump-if-addr>= loop/disp32" -30507 0x20/imm32/size -30508 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 -30509 _string_0f_84_jump_label: # (payload array byte) -30510 0x11/imm32/alloc-id:fake:payload -30511 # "0f 84/jump-if-=" -30512 0xf/imm32/size -30513 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/= -30514 _string_0f_84_jump_break: # (payload array byte) -30515 0x11/imm32/alloc-id:fake:payload -30516 # "0f 84/jump-if-= break/disp32" -30517 0x1c/imm32/size -30518 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 -30519 _string_0f_84_jump_loop: # (payload array byte) -30520 0x11/imm32/alloc-id:fake:payload -30521 # "0f 84/jump-if-= loop/disp32" -30522 0x1b/imm32/size -30523 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 -30524 _string_0f_85_jump_label: # (payload array byte) -30525 0x11/imm32/alloc-id:fake:payload -30526 # "0f 85/jump-if-!=" -30527 0x10/imm32/size -30528 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/= -30529 _string_0f_85_jump_break: # (payload array byte) -30530 0x11/imm32/alloc-id:fake:payload -30531 # "0f 85/jump-if-!= break/disp32" -30532 0x1d/imm32/size -30533 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 -30534 _string_0f_85_jump_loop: # (payload array byte) -30535 0x11/imm32/alloc-id:fake:payload -30536 # "0f 85/jump-if-!= loop/disp32" -30537 0x1c/imm32/size -30538 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 -30539 _string_0f_86_jump_label: # (payload array byte) -30540 0x11/imm32/alloc-id:fake:payload -30541 # "0f 86/jump-if-addr<=" -30542 0x14/imm32/size -30543 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/= -30544 _string_0f_86_jump_break: # (payload array byte) -30545 0x11/imm32/alloc-id:fake:payload -30546 # "0f 86/jump-if-addr<= break/disp32" -30547 0x21/imm32/size -30548 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 -30549 _string_0f_86_jump_loop: # (payload array byte) -30550 0x11/imm32/alloc-id:fake:payload -30551 # "0f 86/jump-if-addr<= loop/disp32" -30552 0x20/imm32/size -30553 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 -30554 _string_0f_87_jump_label: # (payload array byte) -30555 0x11/imm32/alloc-id:fake:payload -30556 # "0f 87/jump-if-addr>" -30557 0x13/imm32/size -30558 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/> -30559 _string_0f_87_jump_break: # (payload array byte) -30560 0x11/imm32/alloc-id:fake:payload -30561 # "0f 87/jump-if-addr> break/disp32" -30562 0x20/imm32/size -30563 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 -30564 _string_0f_87_jump_loop: # (payload array byte) -30565 0x11/imm32/alloc-id:fake:payload -30566 # "0f 87/jump-if-addr> loop/disp32" -30567 0x1f/imm32/size -30568 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 -30569 _string_0f_8c_jump_label: # (payload array byte) -30570 0x11/imm32/alloc-id:fake:payload -30571 # "0f 8c/jump-if-<" -30572 0xf/imm32/size -30573 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/< -30574 _string_0f_8c_jump_break: # (payload array byte) +30481 0x11/imm32/alloc-id:fake +30482 _string-break-if-=/imm32/name +30483 0x11/imm32/alloc-id:fake +30484 Single-lit-var/imm32/inouts +30485 0/imm32/no-outputs +30486 0/imm32/no-outputs +30487 0x11/imm32/alloc-id:fake +30488 _string_0f_84_jump_label/imm32/subx-name +30489 0/imm32/no-rm32 +30490 0/imm32/no-r32 +30491 0/imm32/no-imm32 +30492 0/imm32/no-imm8 +30493 1/imm32/disp32-is-first-inout +30494 0/imm32/no-xm32 +30495 0/imm32/no-x32 +30496 0x11/imm32/alloc-id:fake +30497 _Primitive-break-if-!=-named/imm32/next +30498 _Primitive-break-if-!=-named: # (payload primitive) +30499 0x11/imm32/alloc-id:fake:payload +30500 0x11/imm32/alloc-id:fake +30501 _string-break-if-!=/imm32/name +30502 0x11/imm32/alloc-id:fake +30503 Single-lit-var/imm32/inouts +30504 0/imm32/no-outputs +30505 0/imm32/no-outputs +30506 0x11/imm32/alloc-id:fake +30507 _string_0f_85_jump_label/imm32/subx-name +30508 0/imm32/no-rm32 +30509 0/imm32/no-r32 +30510 0/imm32/no-imm32 +30511 0/imm32/no-imm8 +30512 1/imm32/disp32-is-first-inout +30513 0/imm32/no-xm32 +30514 0/imm32/no-x32 +30515 0x11/imm32/alloc-id:fake +30516 _Primitive-break-if-addr<=-named/imm32/next +30517 _Primitive-break-if-addr<=-named: # (payload primitive) +30518 0x11/imm32/alloc-id:fake:payload +30519 0x11/imm32/alloc-id:fake +30520 _string-break-if-addr<=/imm32/name +30521 0x11/imm32/alloc-id:fake +30522 Single-lit-var/imm32/inouts +30523 0/imm32/no-outputs +30524 0/imm32/no-outputs +30525 0x11/imm32/alloc-id:fake +30526 _string_0f_86_jump_label/imm32/subx-name +30527 0/imm32/no-rm32 +30528 0/imm32/no-r32 +30529 0/imm32/no-imm32 +30530 0/imm32/no-imm8 +30531 1/imm32/disp32-is-first-inout +30532 0/imm32/no-xm32 +30533 0/imm32/no-x32 +30534 0x11/imm32/alloc-id:fake +30535 _Primitive-break-if-addr>-named/imm32/next +30536 _Primitive-break-if-addr>-named: # (payload primitive) +30537 0x11/imm32/alloc-id:fake:payload +30538 0x11/imm32/alloc-id:fake +30539 _string-break-if-addr>/imm32/name +30540 0x11/imm32/alloc-id:fake +30541 Single-lit-var/imm32/inouts +30542 0/imm32/no-outputs +30543 0/imm32/no-outputs +30544 0x11/imm32/alloc-id:fake +30545 _string_0f_87_jump_label/imm32/subx-name +30546 0/imm32/no-rm32 +30547 0/imm32/no-r32 +30548 0/imm32/no-imm32 +30549 0/imm32/no-imm8 +30550 1/imm32/disp32-is-first-inout +30551 0/imm32/no-xm32 +30552 0/imm32/no-x32 +30553 0x11/imm32/alloc-id:fake +30554 _Primitive-break-if-<-named/imm32/next +30555 _Primitive-break-if-<-named: # (payload primitive) +30556 0x11/imm32/alloc-id:fake:payload +30557 0x11/imm32/alloc-id:fake +30558 _string-break-if-</imm32/name +30559 0x11/imm32/alloc-id:fake +30560 Single-lit-var/imm32/inouts +30561 0/imm32/no-outputs +30562 0/imm32/no-outputs +30563 0x11/imm32/alloc-id:fake +30564 _string_0f_8c_jump_label/imm32/subx-name +30565 0/imm32/no-rm32 +30566 0/imm32/no-r32 +30567 0/imm32/no-imm32 +30568 0/imm32/no-imm8 +30569 1/imm32/disp32-is-first-inout +30570 0/imm32/no-xm32 +30571 0/imm32/no-x32 +30572 0x11/imm32/alloc-id:fake +30573 _Primitive-break-if->=-named/imm32/next +30574 _Primitive-break-if->=-named: # (payload primitive) 30575 0x11/imm32/alloc-id:fake:payload -30576 # "0f 8c/jump-if-< break/disp32" -30577 0x1c/imm32/size -30578 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 -30579 _string_0f_8c_jump_loop: # (payload array byte) -30580 0x11/imm32/alloc-id:fake:payload -30581 # "0f 8c/jump-if-< loop/disp32" -30582 0x1b/imm32/size -30583 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 -30584 _string_0f_8d_jump_label: # (payload array byte) -30585 0x11/imm32/alloc-id:fake:payload -30586 # "0f 8d/jump-if->=" -30587 0x10/imm32/size -30588 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/= -30589 _string_0f_8d_jump_break: # (payload array byte) -30590 0x11/imm32/alloc-id:fake:payload -30591 # "0f 8d/jump-if->= break/disp32" -30592 0x1d/imm32/size -30593 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 -30594 _string_0f_8d_jump_loop: # (payload array byte) -30595 0x11/imm32/alloc-id:fake:payload -30596 # "0f 8d/jump-if->= loop/disp32" -30597 0x1c/imm32/size -30598 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 -30599 _string_0f_8e_jump_label: # (payload array byte) -30600 0x11/imm32/alloc-id:fake:payload -30601 # "0f 8e/jump-if-<=" -30602 0x10/imm32/size -30603 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/= -30604 _string_0f_8e_jump_break: # (payload array byte) -30605 0x11/imm32/alloc-id:fake:payload -30606 # "0f 8e/jump-if-<= break/disp32" -30607 0x1d/imm32/size -30608 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 -30609 _string_0f_8e_jump_loop: # (payload array byte) -30610 0x11/imm32/alloc-id:fake:payload -30611 # "0f 8e/jump-if-<= loop/disp32" -30612 0x1c/imm32/size -30613 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 -30614 _string_0f_8f_jump_label: # (payload array byte) -30615 0x11/imm32/alloc-id:fake:payload -30616 # "0f 8f/jump-if->" -30617 0xf/imm32/size -30618 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/> -30619 _string_0f_8f_jump_break: # (payload array byte) -30620 0x11/imm32/alloc-id:fake:payload -30621 # "0f 8f/jump-if-> break/disp32" -30622 0x1c/imm32/size -30623 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 -30624 _string_0f_8f_jump_loop: # (payload array byte) -30625 0x11/imm32/alloc-id:fake:payload -30626 # "0f 8f/jump-if-> loop/disp32" -30627 0x1b/imm32/size -30628 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 -30629 _string_0f_af_multiply: # (payload array byte) -30630 0x11/imm32/alloc-id:fake:payload -30631 # "0f af/multiply" -30632 0xe/imm32/size -30633 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 -30634 _string_f3_0f_2a_convert_to_float: -30635 0x11/imm32/alloc-id:fake:payload -30636 # "f3 0f 2a/convert-to-float" -30637 0x19/imm32/size -30638 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x32/2 0x61/a 0x2f/slash 0x63/c 0x6f/o 0x6e/n 0x76/v 0x65/e 0x72/r 0x74/t 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t -30639 _string_f3_0f_2d_convert_to_int: -30640 0x11/imm32/alloc-id:fake:payload -30641 # "f3 0f 2d/convert-to-int" -30642 0x17/imm32/size -30643 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x32/2 0x64/d 0x2f/slash 0x63/c 0x6f/o 0x6e/n 0x76/v 0x65/e 0x72/r 0x74/t 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x69/i 0x6e/n 0x74/t -30644 _string_f3_0f_2c_truncate_to_int: -30645 0x11/imm32/alloc-id:fake:payload -30646 # "f3 0f 2c/truncate-to-int" -30647 0x18/imm32/size -30648 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x32/2 0x63/c 0x2f/slash 0x74/t 0x72/r 0x75/u 0x6e/n 0x63/c 0x61/a 0x74/t 0x65/e 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x69/i 0x6e/n 0x74/t -30649 _string_f3_0f_58_add: -30650 0x11/imm32/alloc-id:fake:payload -30651 # "f3 0f 58/add" -30652 0xc/imm32/size -30653 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x38/8 0x2f/slash 0x61/a 0x64/d 0x64/d -30654 _string_f3_0f_5c_subtract: -30655 0x11/imm32/alloc-id:fake:payload -30656 # "f3 0f 5c/subtract" -30657 0x11/imm32/size -30658 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x63/c 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t -30659 _string_f3_0f_59_multiply: -30660 0x11/imm32/alloc-id:fake:payload -30661 # "f3 0f 59/multiply" -30662 0x11/imm32/size -30663 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x39/9 0x2f/slash 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y -30664 _string_f3_0f_5e_divide: -30665 0x11/imm32/alloc-id:fake:payload -30666 # "f3 0f 5e/divide" -30667 0xf/imm32/size -30668 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x65/e 0x2f/slash 0x64/d 0x69/i 0x76/v 0x69/i 0x64/d 0x65/e -30669 _string_f3_0f_53_reciprocal: +30576 0x11/imm32/alloc-id:fake +30577 _string-break-if->=/imm32/name +30578 0x11/imm32/alloc-id:fake +30579 Single-lit-var/imm32/inouts +30580 0/imm32/no-outputs +30581 0/imm32/no-outputs +30582 0x11/imm32/alloc-id:fake +30583 _string_0f_8d_jump_label/imm32/subx-name +30584 0/imm32/no-rm32 +30585 0/imm32/no-r32 +30586 0/imm32/no-imm32 +30587 0/imm32/no-imm8 +30588 1/imm32/disp32-is-first-inout +30589 0/imm32/no-xm32 +30590 0/imm32/no-x32 +30591 0x11/imm32/alloc-id:fake +30592 _Primitive-break-if-<=-named/imm32/next +30593 _Primitive-break-if-<=-named: # (payload primitive) +30594 0x11/imm32/alloc-id:fake:payload +30595 0x11/imm32/alloc-id:fake +30596 _string-break-if-<=/imm32/name +30597 0x11/imm32/alloc-id:fake +30598 Single-lit-var/imm32/inouts +30599 0/imm32/no-outputs +30600 0/imm32/no-outputs +30601 0x11/imm32/alloc-id:fake +30602 _string_0f_8e_jump_label/imm32/subx-name +30603 0/imm32/no-rm32 +30604 0/imm32/no-r32 +30605 0/imm32/no-imm32 +30606 0/imm32/no-imm8 +30607 1/imm32/disp32-is-first-inout +30608 0/imm32/no-xm32 +30609 0/imm32/no-x32 +30610 0x11/imm32/alloc-id:fake +30611 _Primitive-break-if->-named/imm32/next +30612 _Primitive-break-if->-named: # (payload primitive) +30613 0x11/imm32/alloc-id:fake:payload +30614 0x11/imm32/alloc-id:fake +30615 _string-break-if->/imm32/name +30616 0x11/imm32/alloc-id:fake +30617 Single-lit-var/imm32/inouts +30618 0/imm32/no-outputs +30619 0/imm32/no-outputs +30620 0x11/imm32/alloc-id:fake +30621 _string_0f_8f_jump_label/imm32/subx-name +30622 0/imm32/no-rm32 +30623 0/imm32/no-r32 +30624 0/imm32/no-imm32 +30625 0/imm32/no-imm8 +30626 1/imm32/disp32-is-first-inout +30627 0/imm32/no-xm32 +30628 0/imm32/no-x32 +30629 0x11/imm32/alloc-id:fake +30630 _Primitive-break-named/imm32/next +30631 _Primitive-break-named: # (payload primitive) +30632 0x11/imm32/alloc-id:fake:payload +30633 0x11/imm32/alloc-id:fake +30634 _string-break/imm32/name +30635 0x11/imm32/alloc-id:fake +30636 Single-lit-var/imm32/inouts +30637 0/imm32/no-outputs +30638 0/imm32/no-outputs +30639 0x11/imm32/alloc-id:fake +30640 _string_e9_jump_label/imm32/subx-name +30641 0/imm32/no-rm32 +30642 0/imm32/no-r32 +30643 0/imm32/no-imm32 +30644 0/imm32/no-imm8 +30645 1/imm32/disp32-is-first-inout +30646 0/imm32/no-xm32 +30647 0/imm32/no-x32 +30648 0x11/imm32/alloc-id:fake +30649 _Primitive-loop-if-addr<-named/imm32/next +30650 _Primitive-loop-if-addr<-named: # (payload primitive) +30651 0x11/imm32/alloc-id:fake:payload +30652 0x11/imm32/alloc-id:fake +30653 _string-loop-if-addr</imm32/name +30654 0x11/imm32/alloc-id:fake +30655 Single-lit-var/imm32/inouts +30656 0/imm32/no-outputs +30657 0/imm32/no-outputs +30658 0x11/imm32/alloc-id:fake +30659 _string_0f_82_jump_label/imm32/subx-name +30660 0/imm32/no-rm32 +30661 0/imm32/no-r32 +30662 0/imm32/no-imm32 +30663 0/imm32/no-imm8 +30664 1/imm32/disp32-is-first-inout +30665 0/imm32/no-xm32 +30666 0/imm32/no-x32 +30667 0x11/imm32/alloc-id:fake +30668 _Primitive-loop-if-addr>=-named/imm32/next +30669 _Primitive-loop-if-addr>=-named: # (payload primitive) 30670 0x11/imm32/alloc-id:fake:payload -30671 # "f3 0f 53/reciprocal" -30672 0x13/imm32/size -30673 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x33/3 0x2f/slash 0x72/r 0x65/e 0x63/c 0x69/i 0x70/p 0x72/r 0x6f/o 0x63/c 0x61/a 0x6c/l -30674 _string_f3_0f_51_square_root: -30675 0x11/imm32/alloc-id:fake:payload -30676 # "f3 0f 51/square-root" -30677 0x14/imm32/size -30678 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x31/1 0x2f/slash 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/dash 0x72/r 0x6f/o 0x6f/o 0x74/t -30679 _string_f3_0f_52_inverse_square_root: -30680 0x11/imm32/alloc-id:fake:payload -30681 # "f3 0f 52/inverse-square-root" -30682 0x1c/imm32/size -30683 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x32/2 0x2f/slash 0x69/i 0x6e/n 0x76/v 0x65/e 0x72/r 0x73/s 0x65/e 0x2d/dash 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/dash 0x72/r 0x6f/o 0x6f/o 0x74/t -30684 _string_f3_0f_5d_min: -30685 0x11/imm32/alloc-id:fake:payload -30686 # "f3 0f 5d/min" -30687 0xc/imm32/size -30688 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x64/d 0x2f/slash 0x6d/m 0x69/i 0x6e/n -30689 _string_f3_0f_5f_max: -30690 0x11/imm32/alloc-id:fake:payload -30691 # "f3 0f 5f/max" -30692 0xc/imm32/size -30693 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x66/f 0x2f/slash 0x6d/m 0x61/a 0x78/x -30694 _string_f3_0f_10_copy: -30695 0x11/imm32/alloc-id:fake:payload -30696 # "f3 0f 10/copy" -30697 0xd/imm32/size -30698 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x31/1 0x30/0 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y -30699 _string_f3_0f_11_copy: -30700 0x11/imm32/alloc-id:fake:payload -30701 # "f3 0f 11/copy" -30702 0xd/imm32/size -30703 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x31/1 0x31/1 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y -30704 _string_0f_2f_compare: -30705 0x11/imm32/alloc-id:fake:payload -30706 # "0f 2f/compare" -30707 0xd/imm32/size -30708 0x30/0 0x66/f 0x20/space 0x32/2 0x66/f 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e -30709 _string_21_and_with: # (payload array byte) -30710 0x11/imm32/alloc-id:fake:payload -30711 # "21/and-with" -30712 0xb/imm32/size -30713 0x32/2 0x31/1 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -30714 _string_23_and: # (payload array byte) -30715 0x11/imm32/alloc-id:fake:payload -30716 # "23/and" -30717 0x6/imm32/size -30718 0x32/2 0x33/3 0x2f/slash 0x61/a 0x6e/n 0x64/d -30719 _string_25_and_with_eax: # (payload array byte) -30720 0x11/imm32/alloc-id:fake:payload -30721 # "25/and-with-eax" -30722 0xf/imm32/size -30723 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 -30724 _string_29_subtract_from: # (payload array byte) -30725 0x11/imm32/alloc-id:fake:payload -30726 # "29/subtract-from" -30727 0x10/imm32/size -30728 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 -30729 _string_2b_subtract: # (payload array byte) -30730 0x11/imm32/alloc-id:fake:payload -30731 # "2b/subtract" -30732 0xb/imm32/size -30733 0x32/2 0x62/b 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t -30734 _string_2d_subtract_from_eax: # (payload array byte) -30735 0x11/imm32/alloc-id:fake:payload -30736 # "2d/subtract-from-eax" -30737 0x14/imm32/size -30738 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 -30739 _string_31_xor_with: # (payload array byte) -30740 0x11/imm32/alloc-id:fake:payload -30741 # "31/xor-with" -30742 0xb/imm32/size -30743 0x33/3 0x31/1 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h -30744 _string_33_xor: # (payload array byte) -30745 0x11/imm32/alloc-id:fake:payload -30746 # "33/xor" -30747 0x6/imm32/size -30748 0x33/3 0x33/3 0x2f/slash 0x78/x 0x6f/o 0x72/r -30749 _string_35_xor_with_eax: # (payload array byte) -30750 0x11/imm32/alloc-id:fake:payload -30751 # "35/xor-with-eax" -30752 0xf/imm32/size -30753 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 -30754 _string_39_compare->: # (payload array byte) -30755 0x11/imm32/alloc-id:fake:payload -30756 # "39/compare->" -30757 0xc/imm32/size -30758 0x33/3 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x3e/> -30759 _string_3b_compare<-: # (payload array byte) -30760 0x11/imm32/alloc-id:fake:payload -30761 # "3b/compare<-" -30762 0xc/imm32/size -30763 0x33/3 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x3c/< 0x2d/dash -30764 _string_3d_compare_eax_with: # (payload array byte) +30671 0x11/imm32/alloc-id:fake +30672 _string-loop-if-addr>=/imm32/name +30673 0x11/imm32/alloc-id:fake +30674 Single-lit-var/imm32/inouts +30675 0/imm32/no-outputs +30676 0/imm32/no-outputs +30677 0x11/imm32/alloc-id:fake +30678 _string_0f_83_jump_label/imm32/subx-name +30679 0/imm32/no-rm32 +30680 0/imm32/no-r32 +30681 0/imm32/no-imm32 +30682 0/imm32/no-imm8 +30683 1/imm32/disp32-is-first-inout +30684 0/imm32/no-xm32 +30685 0/imm32/no-x32 +30686 0x11/imm32/alloc-id:fake +30687 _Primitive-loop-if-=-named/imm32/next +30688 _Primitive-loop-if-=-named: # (payload primitive) +30689 0x11/imm32/alloc-id:fake:payload +30690 0x11/imm32/alloc-id:fake +30691 _string-loop-if-=/imm32/name +30692 0x11/imm32/alloc-id:fake +30693 Single-lit-var/imm32/inouts +30694 0/imm32/no-outputs +30695 0/imm32/no-outputs +30696 0x11/imm32/alloc-id:fake +30697 _string_0f_84_jump_label/imm32/subx-name +30698 0/imm32/no-rm32 +30699 0/imm32/no-r32 +30700 0/imm32/no-imm32 +30701 0/imm32/no-imm8 +30702 1/imm32/disp32-is-first-inout +30703 0/imm32/no-xm32 +30704 0/imm32/no-x32 +30705 0x11/imm32/alloc-id:fake +30706 _Primitive-loop-if-!=-named/imm32/next +30707 _Primitive-loop-if-!=-named: # (payload primitive) +30708 0x11/imm32/alloc-id:fake:payload +30709 0x11/imm32/alloc-id:fake +30710 _string-loop-if-!=/imm32/name +30711 0x11/imm32/alloc-id:fake +30712 Single-lit-var/imm32/inouts +30713 0/imm32/no-outputs +30714 0/imm32/no-outputs +30715 0x11/imm32/alloc-id:fake +30716 _string_0f_85_jump_label/imm32/subx-name +30717 0/imm32/no-rm32 +30718 0/imm32/no-r32 +30719 0/imm32/no-imm32 +30720 0/imm32/no-imm8 +30721 1/imm32/disp32-is-first-inout +30722 0/imm32/no-xm32 +30723 0/imm32/no-x32 +30724 0x11/imm32/alloc-id:fake +30725 _Primitive-loop-if-addr<=-named/imm32/next +30726 _Primitive-loop-if-addr<=-named: # (payload primitive) +30727 0x11/imm32/alloc-id:fake:payload +30728 0x11/imm32/alloc-id:fake +30729 _string-loop-if-addr<=/imm32/name +30730 0x11/imm32/alloc-id:fake +30731 Single-lit-var/imm32/inouts +30732 0/imm32/no-outputs +30733 0/imm32/no-outputs +30734 0x11/imm32/alloc-id:fake +30735 _string_0f_86_jump_label/imm32/subx-name +30736 0/imm32/no-rm32 +30737 0/imm32/no-r32 +30738 0/imm32/no-imm32 +30739 0/imm32/no-imm8 +30740 1/imm32/disp32-is-first-inout +30741 0/imm32/no-xm32 +30742 0/imm32/no-x32 +30743 0x11/imm32/alloc-id:fake +30744 _Primitive-loop-if-addr>-named/imm32/next +30745 _Primitive-loop-if-addr>-named: # (payload primitive) +30746 0x11/imm32/alloc-id:fake:payload +30747 0x11/imm32/alloc-id:fake +30748 _string-loop-if-addr>/imm32/name +30749 0x11/imm32/alloc-id:fake +30750 Single-lit-var/imm32/inouts +30751 0/imm32/no-outputs +30752 0/imm32/no-outputs +30753 0x11/imm32/alloc-id:fake +30754 _string_0f_87_jump_label/imm32/subx-name +30755 0/imm32/no-rm32 +30756 0/imm32/no-r32 +30757 0/imm32/no-imm32 +30758 0/imm32/no-imm8 +30759 1/imm32/disp32-is-first-inout +30760 0/imm32/no-xm32 +30761 0/imm32/no-x32 +30762 0x11/imm32/alloc-id:fake +30763 _Primitive-loop-if-<-named/imm32/next +30764 _Primitive-loop-if-<-named: # (payload primitive) 30765 0x11/imm32/alloc-id:fake:payload -30766 # "3d/compare-eax-with" -30767 0x13/imm32/size -30768 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 -30769 _string_40_increment_eax: # (payload array byte) -30770 0x11/imm32/alloc-id:fake:payload -30771 # "40/increment-eax" -30772 0x10/imm32/size -30773 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 -30774 _string_41_increment_ecx: # (payload array byte) -30775 0x11/imm32/alloc-id:fake:payload -30776 # "41/increment-ecx" -30777 0x10/imm32/size -30778 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 -30779 _string_42_increment_edx: # (payload array byte) -30780 0x11/imm32/alloc-id:fake:payload -30781 # "42/increment-edx" -30782 0x10/imm32/size -30783 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 -30784 _string_43_increment_ebx: # (payload array byte) -30785 0x11/imm32/alloc-id:fake:payload -30786 # "43/increment-ebx" -30787 0x10/imm32/size -30788 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 -30789 _string_46_increment_esi: # (payload array byte) -30790 0x11/imm32/alloc-id:fake:payload -30791 # "46/increment-esi" -30792 0x10/imm32/size -30793 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 -30794 _string_47_increment_edi: # (payload array byte) -30795 0x11/imm32/alloc-id:fake:payload -30796 # "47/increment-edi" -30797 0x10/imm32/size -30798 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 -30799 _string_48_decrement_eax: # (payload array byte) -30800 0x11/imm32/alloc-id:fake:payload -30801 # "48/decrement-eax" -30802 0x10/imm32/size -30803 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 -30804 _string_49_decrement_ecx: # (payload array byte) -30805 0x11/imm32/alloc-id:fake:payload -30806 # "49/decrement-ecx" -30807 0x10/imm32/size -30808 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 -30809 _string_4a_decrement_edx: # (payload array byte) -30810 0x11/imm32/alloc-id:fake:payload -30811 # "4a/decrement-edx" -30812 0x10/imm32/size -30813 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 -30814 _string_4b_decrement_ebx: # (payload array byte) -30815 0x11/imm32/alloc-id:fake:payload -30816 # "4b/decrement-ebx" -30817 0x10/imm32/size -30818 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 -30819 _string_4e_decrement_esi: # (payload array byte) -30820 0x11/imm32/alloc-id:fake:payload -30821 # "4e/decrement-esi" -30822 0x10/imm32/size -30823 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 -30824 _string_4f_decrement_edi: # (payload array byte) -30825 0x11/imm32/alloc-id:fake:payload -30826 # "4f/decrement-edi" -30827 0x10/imm32/size -30828 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 -30829 _string_81_subop_add: # (payload array byte) -30830 0x11/imm32/alloc-id:fake:payload -30831 # "81 0/subop/add" -30832 0xe/imm32/size -30833 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 -30834 _string_81_subop_or: # (payload array byte) -30835 0x11/imm32/alloc-id:fake:payload -30836 # "81 1/subop/or" -30837 0xd/imm32/size -30838 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 -30839 _string_81_subop_and: # (payload array byte) -30840 0x11/imm32/alloc-id:fake:payload -30841 # "81 4/subop/and" -30842 0xe/imm32/size -30843 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 -30844 _string_81_subop_subtract: # (payload array byte) -30845 0x11/imm32/alloc-id:fake:payload -30846 # "81 5/subop/subtract" -30847 0x13/imm32/size -30848 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 -30849 _string_81_subop_xor: # (payload array byte) -30850 0x11/imm32/alloc-id:fake:payload -30851 # "81 6/subop/xor" -30852 0xe/imm32/size -30853 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 -30854 _string_81_subop_compare: # (payload array byte) -30855 0x11/imm32/alloc-id:fake:payload -30856 # "81 7/subop/compare" -30857 0x12/imm32/size -30858 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 -30859 _string_89_<-: # (payload array byte) -30860 0x11/imm32/alloc-id:fake:payload -30861 # "89/<-" -30862 0x5/imm32/size -30863 0x38/8 0x39/9 0x2f/slash 0x3c/< 0x2d/dash -30864 _string_8b_->: # (payload array byte) -30865 0x11/imm32/alloc-id:fake:payload -30866 # "8b/->" -30867 0x5/imm32/size -30868 0x38/8 0x62/b 0x2f/slash 0x2d/dash 0x3e/> -30869 _string_8a_copy_byte: -30870 0x11/imm32/alloc-id:fake:payload -30871 # "8a/byte->" -30872 0x9/imm32/size -30873 0x38/8 0x61/a 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x3e/> -30874 _string_88_copy_byte: -30875 0x11/imm32/alloc-id:fake:payload -30876 # "88/byte<-" -30877 0x9/imm32/size -30878 0x38/8 0x38/8 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x3c/< 0x2d/- -30879 _string_8d_copy_address: # (payload array byte) +30766 0x11/imm32/alloc-id:fake +30767 _string-loop-if-</imm32/name +30768 0x11/imm32/alloc-id:fake +30769 Single-lit-var/imm32/inouts +30770 0/imm32/no-outputs +30771 0/imm32/no-outputs +30772 0x11/imm32/alloc-id:fake +30773 _string_0f_8c_jump_label/imm32/subx-name +30774 0/imm32/no-rm32 +30775 0/imm32/no-r32 +30776 0/imm32/no-imm32 +30777 0/imm32/no-imm8 +30778 1/imm32/disp32-is-first-inout +30779 0/imm32/no-xm32 +30780 0/imm32/no-x32 +30781 0x11/imm32/alloc-id:fake +30782 _Primitive-loop-if->=-named/imm32/next +30783 _Primitive-loop-if->=-named: # (payload primitive) +30784 0x11/imm32/alloc-id:fake:payload +30785 0x11/imm32/alloc-id:fake +30786 _string-loop-if->=/imm32/name +30787 0x11/imm32/alloc-id:fake +30788 Single-lit-var/imm32/inouts +30789 0/imm32/no-outputs +30790 0/imm32/no-outputs +30791 0x11/imm32/alloc-id:fake +30792 _string_0f_8d_jump_label/imm32/subx-name +30793 0/imm32/no-rm32 +30794 0/imm32/no-r32 +30795 0/imm32/no-imm32 +30796 0/imm32/no-imm8 +30797 1/imm32/disp32-is-first-inout +30798 0/imm32/no-xm32 +30799 0/imm32/no-x32 +30800 0x11/imm32/alloc-id:fake +30801 _Primitive-loop-if-<=-named/imm32/next +30802 _Primitive-loop-if-<=-named: # (payload primitive) +30803 0x11/imm32/alloc-id:fake:payload +30804 0x11/imm32/alloc-id:fake +30805 _string-loop-if-<=/imm32/name +30806 0x11/imm32/alloc-id:fake +30807 Single-lit-var/imm32/inouts +30808 0/imm32/no-outputs +30809 0/imm32/no-outputs +30810 0x11/imm32/alloc-id:fake +30811 _string_0f_8e_jump_label/imm32/subx-name +30812 0/imm32/no-rm32 +30813 0/imm32/no-r32 +30814 0/imm32/no-imm32 +30815 0/imm32/no-imm8 +30816 1/imm32/disp32-is-first-inout +30817 0/imm32/no-xm32 +30818 0/imm32/no-x32 +30819 0x11/imm32/alloc-id:fake +30820 _Primitive-loop-if->-named/imm32/next +30821 _Primitive-loop-if->-named: # (payload primitive) +30822 0x11/imm32/alloc-id:fake:payload +30823 0x11/imm32/alloc-id:fake +30824 _string-loop-if->/imm32/name +30825 0x11/imm32/alloc-id:fake +30826 Single-lit-var/imm32/inouts +30827 0/imm32/no-outputs +30828 0/imm32/no-outputs +30829 0x11/imm32/alloc-id:fake +30830 _string_0f_8f_jump_label/imm32/subx-name +30831 0/imm32/no-rm32 +30832 0/imm32/no-r32 +30833 0/imm32/no-imm32 +30834 0/imm32/no-imm8 +30835 1/imm32/disp32-is-first-inout +30836 0/imm32/no-xm32 +30837 0/imm32/no-x32 +30838 0x11/imm32/alloc-id:fake +30839 _Primitive-loop-named/imm32/next # we probably don't need an unconditional break +30840 _Primitive-loop-named: # (payload primitive) +30841 0x11/imm32/alloc-id:fake:payload +30842 0x11/imm32/alloc-id:fake +30843 _string-loop/imm32/name +30844 0x11/imm32/alloc-id:fake +30845 Single-lit-var/imm32/inouts +30846 0/imm32/no-outputs +30847 0/imm32/no-outputs +30848 0x11/imm32/alloc-id:fake +30849 _string_e9_jump_label/imm32/subx-name +30850 0/imm32/no-rm32 +30851 0/imm32/no-r32 +30852 0/imm32/no-imm32 +30853 0/imm32/no-imm8 +30854 1/imm32/disp32-is-first-inout +30855 0/imm32/no-xm32 +30856 0/imm32/no-x32 +30857 0x11/imm32/alloc-id:fake +30858 _Primitive-break-if-float</imm32/next +30859 # - branches based on floating-point comparisons +30860 _Primitive-break-if-float<: # (payload primitive) +30861 0x11/imm32/alloc-id:fake:payload +30862 0x11/imm32/alloc-id:fake +30863 _string-break-if-float</imm32/name +30864 0/imm32/no-inouts +30865 0/imm32/no-inouts +30866 0/imm32/no-outputs +30867 0/imm32/no-outputs +30868 0x11/imm32/alloc-id:fake +30869 _string_0f_82_jump_break/imm32/subx-name +30870 0/imm32/no-rm32 +30871 0/imm32/no-r32 +30872 0/imm32/no-imm32 +30873 0/imm32/no-imm8 +30874 0/imm32/no-disp32 +30875 0/imm32/no-xm32 +30876 0/imm32/no-x32 +30877 0x11/imm32/alloc-id:fake +30878 _Primitive-break-if-float>=/imm32/next +30879 _Primitive-break-if-float>=: # (payload primitive) 30880 0x11/imm32/alloc-id:fake:payload -30881 # "8d/copy-address" -30882 0xf/imm32/size -30883 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 -30884 _string_b8_copy_to_eax: # (payload array byte) -30885 0x11/imm32/alloc-id:fake:payload -30886 # "b8/copy-to-eax" -30887 0xe/imm32/size -30888 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 -30889 _string_b9_copy_to_ecx: # (payload array byte) -30890 0x11/imm32/alloc-id:fake:payload -30891 # "b9/copy-to-ecx" -30892 0xe/imm32/size -30893 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 -30894 _string_ba_copy_to_edx: # (payload array byte) -30895 0x11/imm32/alloc-id:fake:payload -30896 # "ba/copy-to-edx" -30897 0xe/imm32/size -30898 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 -30899 _string_bb_copy_to_ebx: # (payload array byte) -30900 0x11/imm32/alloc-id:fake:payload -30901 # "bb/copy-to-ebx" -30902 0xe/imm32/size -30903 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 -30904 _string_be_copy_to_esi: # (payload array byte) -30905 0x11/imm32/alloc-id:fake:payload -30906 # "be/copy-to-esi" -30907 0xe/imm32/size -30908 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 -30909 _string_bf_copy_to_edi: # (payload array byte) -30910 0x11/imm32/alloc-id:fake:payload -30911 # "bf/copy-to-edi" -30912 0xe/imm32/size -30913 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 -30914 _string_c7_subop_copy: # (payload array byte) -30915 0x11/imm32/alloc-id:fake:payload -30916 # "c7 0/subop/copy" -30917 0xf/imm32/size -30918 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 -30919 _string_e9_jump_label: # (payload array byte) -30920 0x11/imm32/alloc-id:fake:payload -30921 # "e9/jump" -30922 0x7/imm32/size -30923 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p -30924 _string_e9_jump_break: # (payload array byte) -30925 0x11/imm32/alloc-id:fake:payload -30926 # "e9/jump break/disp32" -30927 0x14/imm32/size -30928 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 -30929 _string_e9_jump_loop: # (payload array byte) -30930 0x11/imm32/alloc-id:fake:payload -30931 # "e9/jump loop/disp32" -30932 0x13/imm32/size -30933 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 -30934 _string_f7_subop_negate: -30935 0x11/imm32/alloc-id:fake:payload -30936 # "f7 3/subop/negate" -30937 0x11/imm32/size -30938 0x66/f 0x37/7 0x20/space 0x33/3 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6e/n 0x65/e 0x67/g 0x61/a 0x74/t 0x65/e -30939 _string_ff_subop_increment: # (payload array byte) -30940 0x11/imm32/alloc-id:fake:payload -30941 # "ff 0/subop/increment" -30942 0x14/imm32/size -30943 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 -30944 _string_ff_subop_decrement: # (payload array byte) -30945 0x11/imm32/alloc-id:fake:payload -30946 # "ff 1/subop/decrement" -30947 0x14/imm32/size -30948 0x66/f 0x66/f 0x20/space 0x31/1 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t -30949 _string_c1_subop_shift_left: # (payload array byte) -30950 0x11/imm32/alloc-id:fake:payload -30951 # "c1/shift 4/subop/left" -30952 0x15/imm32/size -30953 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x34/4 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6c/l 0x65/e 0x66/f 0x74/t -30954 _string_c1_subop_shift_right_padding_zeroes: # (payload array byte) -30955 0x11/imm32/alloc-id:fake:payload -30956 # "c1/shift 5/subop/right-padding-zeroes" -30957 0x25/imm32/size -30958 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x35/5 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x61/a 0x64/d 0x64/d 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x7a/z 0x65/e 0x72/r 0x6f/o 0x65/e 0x73/s -30959 _string_c1_subop_shift_right_preserving_sign: # (payload array byte) -30960 0x11/imm32/alloc-id:fake:payload -30961 # "c1/shift 7/subop/right-preserving-sign" -30962 0x26/imm32/size -30963 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x37/7 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x72/r 0x65/e 0x73/s 0x65/e 0x72/r 0x76/v 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n -30964 -30965 Single-int-var-in-mem: # (payload list var) -30966 0x11/imm32/alloc-id:fake:payload -30967 0x11/imm32/alloc-id:fake -30968 Int-var-in-mem/imm32 -30969 0/imm32/next -30970 0/imm32/next -30971 -30972 Int-var-in-mem: # (payload var) -30973 0x11/imm32/alloc-id:fake:payload -30974 0/imm32/name -30975 0/imm32/name +30881 0x11/imm32/alloc-id:fake +30882 _string-break-if-float>=/imm32/name +30883 0/imm32/no-inouts +30884 0/imm32/no-inouts +30885 0/imm32/no-outputs +30886 0/imm32/no-outputs +30887 0x11/imm32/alloc-id:fake +30888 _string_0f_83_jump_break/imm32/subx-name +30889 0/imm32/no-rm32 +30890 0/imm32/no-r32 +30891 0/imm32/no-imm32 +30892 0/imm32/no-imm8 +30893 0/imm32/no-disp32 +30894 0/imm32/no-xm32 +30895 0/imm32/no-x32 +30896 0x11/imm32/alloc-id:fake +30897 _Primitive-break-if-float<=/imm32/next +30898 _Primitive-break-if-float<=: # (payload primitive) +30899 0x11/imm32/alloc-id:fake:payload +30900 0x11/imm32/alloc-id:fake +30901 _string-break-if-float<=/imm32/name +30902 0/imm32/no-inouts +30903 0/imm32/no-inouts +30904 0/imm32/no-outputs +30905 0/imm32/no-outputs +30906 0x11/imm32/alloc-id:fake +30907 _string_0f_86_jump_break/imm32/subx-name +30908 0/imm32/no-rm32 +30909 0/imm32/no-r32 +30910 0/imm32/no-imm32 +30911 0/imm32/no-imm8 +30912 0/imm32/no-disp32 +30913 0/imm32/no-xm32 +30914 0/imm32/no-x32 +30915 0x11/imm32/alloc-id:fake +30916 _Primitive-break-if-float>/imm32/next +30917 _Primitive-break-if-float>: # (payload primitive) +30918 0x11/imm32/alloc-id:fake:payload +30919 0x11/imm32/alloc-id:fake +30920 _string-break-if-float>/imm32/name +30921 0/imm32/no-inouts +30922 0/imm32/no-inouts +30923 0/imm32/no-outputs +30924 0/imm32/no-outputs +30925 0x11/imm32/alloc-id:fake +30926 _string_0f_87_jump_break/imm32/subx-name +30927 0/imm32/no-rm32 +30928 0/imm32/no-r32 +30929 0/imm32/no-imm32 +30930 0/imm32/no-imm8 +30931 0/imm32/no-disp32 +30932 0/imm32/no-xm32 +30933 0/imm32/no-x32 +30934 0x11/imm32/alloc-id:fake +30935 _Primitive-loop-if-float</imm32/next +30936 _Primitive-loop-if-float<: # (payload primitive) +30937 0x11/imm32/alloc-id:fake:payload +30938 0x11/imm32/alloc-id:fake +30939 _string-loop-if-float</imm32/name +30940 0/imm32/no-inouts +30941 0/imm32/no-inouts +30942 0/imm32/no-outputs +30943 0/imm32/no-outputs +30944 0x11/imm32/alloc-id:fake +30945 _string_0f_82_jump_loop/imm32/subx-name +30946 0/imm32/no-rm32 +30947 0/imm32/no-r32 +30948 0/imm32/no-imm32 +30949 0/imm32/no-imm8 +30950 0/imm32/no-disp32 +30951 0/imm32/no-xm32 +30952 0/imm32/no-x32 +30953 0x11/imm32/alloc-id:fake +30954 _Primitive-loop-if-float>=/imm32/next +30955 _Primitive-loop-if-float>=: # (payload primitive) +30956 0x11/imm32/alloc-id:fake:payload +30957 0x11/imm32/alloc-id:fake +30958 _string-loop-if-float>=/imm32/name +30959 0/imm32/no-inouts +30960 0/imm32/no-inouts +30961 0/imm32/no-outputs +30962 0/imm32/no-outputs +30963 0x11/imm32/alloc-id:fake +30964 _string_0f_83_jump_loop/imm32/subx-name +30965 0/imm32/no-rm32 +30966 0/imm32/no-r32 +30967 0/imm32/no-imm32 +30968 0/imm32/no-imm8 +30969 0/imm32/no-disp32 +30970 0/imm32/no-xm32 +30971 0/imm32/no-x32 +30972 0x11/imm32/alloc-id:fake +30973 _Primitive-loop-if-float<=/imm32/next +30974 _Primitive-loop-if-float<=: # (payload primitive) +30975 0x11/imm32/alloc-id:fake:payload 30976 0x11/imm32/alloc-id:fake -30977 Type-int/imm32 -30978 1/imm32/some-block-depth -30979 1/imm32/some-stack-offset -30980 0/imm32/no-register -30981 0/imm32/no-register -30982 -30983 # Not really legal, but closest we can currently represent a dereference of an (addr byte) -30984 Single-byte-var-in-mem: # (payload list var) -30985 0x11/imm32/alloc-id:fake:payload -30986 0x11/imm32/alloc-id:fake -30987 Byte-var-in-mem/imm32 -30988 0/imm32/next -30989 0/imm32/next -30990 -30991 # Not really legal, but closest we can currently represent a dereference of an (addr byte) -30992 Byte-var-in-mem: # (payload var) -30993 0x11/imm32/alloc-id:fake:payload -30994 0/imm32/name -30995 0/imm32/name -30996 0x11/imm32/alloc-id:fake -30997 Type-byte/imm32 -30998 1/imm32/some-block-depth -30999 1/imm32/some-stack-offset -31000 0/imm32/no-register -31001 0/imm32/no-register -31002 -31003 Two-args-int-stack-int-reg: # (payload list var) -31004 0x11/imm32/alloc-id:fake:payload -31005 0x11/imm32/alloc-id:fake -31006 Int-var-in-mem/imm32 -31007 0x11/imm32/alloc-id:fake -31008 Single-int-var-in-some-register/imm32/next -31009 -31010 Two-int-args-in-regs: # (payload list var) -31011 0x11/imm32/alloc-id:fake:payload -31012 0x11/imm32/alloc-id:fake -31013 Int-var-in-some-register/imm32 +30977 _string-loop-if-float<=/imm32/name +30978 0/imm32/no-inouts +30979 0/imm32/no-inouts +30980 0/imm32/no-outputs +30981 0/imm32/no-outputs +30982 0x11/imm32/alloc-id:fake +30983 _string_0f_86_jump_loop/imm32/subx-name +30984 0/imm32/no-rm32 +30985 0/imm32/no-r32 +30986 0/imm32/no-imm32 +30987 0/imm32/no-imm8 +30988 0/imm32/no-disp32 +30989 0/imm32/no-xm32 +30990 0/imm32/no-x32 +30991 0x11/imm32/alloc-id:fake +30992 _Primitive-loop-if-float>/imm32/next +30993 _Primitive-loop-if-float>: # (payload primitive) +30994 0x11/imm32/alloc-id:fake:payload +30995 0x11/imm32/alloc-id:fake +30996 _string-loop-if-float>/imm32/name +30997 0/imm32/no-inouts +30998 0/imm32/no-inouts +30999 0/imm32/no-outputs +31000 0/imm32/no-outputs +31001 0x11/imm32/alloc-id:fake +31002 _string_0f_87_jump_loop/imm32/subx-name +31003 0/imm32/no-rm32 +31004 0/imm32/no-r32 +31005 0/imm32/no-imm32 +31006 0/imm32/no-imm8 +31007 0/imm32/no-disp32 +31008 0/imm32/no-xm32 +31009 0/imm32/no-x32 +31010 0x11/imm32/alloc-id:fake +31011 _Primitive-break-if-float<-named/imm32/next +31012 _Primitive-break-if-float<-named: # (payload primitive) +31013 0x11/imm32/alloc-id:fake:payload 31014 0x11/imm32/alloc-id:fake -31015 Single-int-var-in-some-register/imm32/next -31016 -31017 # Not really legal, but closest we can currently represent a dereference of an (addr byte) -31018 Two-args-byte-stack-byte-reg: # (payload list var) -31019 0x11/imm32/alloc-id:fake:payload +31015 _string-break-if-float</imm32/name +31016 0x11/imm32/alloc-id:fake +31017 Single-lit-var/imm32/inouts +31018 0/imm32/no-outputs +31019 0/imm32/no-outputs 31020 0x11/imm32/alloc-id:fake -31021 Byte-var-in-mem/imm32 -31022 0x11/imm32/alloc-id:fake -31023 Single-byte-var-in-some-register/imm32/next -31024 -31025 Two-args-int-reg-int-stack: # (payload list var) -31026 0x11/imm32/alloc-id:fake:payload -31027 0x11/imm32/alloc-id:fake -31028 Int-var-in-some-register/imm32 +31021 _string_0f_82_jump_label/imm32/subx-name +31022 0/imm32/no-rm32 +31023 0/imm32/no-r32 +31024 0/imm32/no-imm32 +31025 0/imm32/no-imm8 +31026 1/imm32/disp32-is-first-inout +31027 0/imm32/no-xm32 +31028 0/imm32/no-x32 31029 0x11/imm32/alloc-id:fake -31030 Single-int-var-in-mem/imm32/next -31031 -31032 Two-args-int-eax-int-literal: # (payload list var) -31033 0x11/imm32/alloc-id:fake:payload -31034 0x11/imm32/alloc-id:fake -31035 Int-var-in-eax/imm32 -31036 0x11/imm32/alloc-id:fake -31037 Single-lit-var/imm32/next -31038 -31039 Int-var-and-literal: # (payload list var) -31040 0x11/imm32/alloc-id:fake:payload -31041 0x11/imm32/alloc-id:fake -31042 Int-var-in-mem/imm32 -31043 0x11/imm32/alloc-id:fake -31044 Single-lit-var/imm32/next -31045 -31046 Int-var-in-register-and-literal: # (payload list var) -31047 0x11/imm32/alloc-id:fake:payload +31030 _Primitive-break-if-float>=-named/imm32/next +31031 _Primitive-break-if-float>=-named: # (payload primitive) +31032 0x11/imm32/alloc-id:fake:payload +31033 0x11/imm32/alloc-id:fake +31034 _string-break-if-float>=/imm32/name +31035 0x11/imm32/alloc-id:fake +31036 Single-lit-var/imm32/inouts +31037 0/imm32/no-outputs +31038 0/imm32/no-outputs +31039 0x11/imm32/alloc-id:fake +31040 _string_0f_83_jump_label/imm32/subx-name +31041 0/imm32/no-rm32 +31042 0/imm32/no-r32 +31043 0/imm32/no-imm32 +31044 0/imm32/no-imm8 +31045 1/imm32/disp32-is-first-inout +31046 0/imm32/no-xm32 +31047 0/imm32/no-x32 31048 0x11/imm32/alloc-id:fake -31049 Int-var-in-some-register/imm32 -31050 0x11/imm32/alloc-id:fake -31051 Single-lit-var/imm32/next -31052 -31053 Two-float-args-in-regs: # (payload list var) -31054 0x11/imm32/alloc-id:fake:payload -31055 0x11/imm32/alloc-id:fake -31056 Float-var-in-some-register/imm32 -31057 0x11/imm32/alloc-id:fake -31058 Single-float-var-in-some-register/imm32/next -31059 -31060 Two-args-float-reg-float-stack: # (payload list var) -31061 0x11/imm32/alloc-id:fake:payload -31062 0x11/imm32/alloc-id:fake -31063 Float-var-in-some-register/imm32 -31064 0x11/imm32/alloc-id:fake -31065 Single-float-var-in-mem/imm32/next -31066 -31067 Two-args-float-stack-float-reg: # (payload list var) -31068 0x11/imm32/alloc-id:fake:payload -31069 0x11/imm32/alloc-id:fake -31070 Float-var-in-mem/imm32 +31049 _Primitive-break-if-float<=-named/imm32/next +31050 _Primitive-break-if-float<=-named: # (payload primitive) +31051 0x11/imm32/alloc-id:fake:payload +31052 0x11/imm32/alloc-id:fake +31053 _string-break-if-float<=/imm32/name +31054 0x11/imm32/alloc-id:fake +31055 Single-lit-var/imm32/inouts +31056 0/imm32/no-outputs +31057 0/imm32/no-outputs +31058 0x11/imm32/alloc-id:fake +31059 _string_0f_86_jump_label/imm32/subx-name +31060 0/imm32/no-rm32 +31061 0/imm32/no-r32 +31062 0/imm32/no-imm32 +31063 0/imm32/no-imm8 +31064 1/imm32/disp32-is-first-inout +31065 0/imm32/no-xm32 +31066 0/imm32/no-x32 +31067 0x11/imm32/alloc-id:fake +31068 _Primitive-break-if-float>-named/imm32/next +31069 _Primitive-break-if-float>-named: # (payload primitive) +31070 0x11/imm32/alloc-id:fake:payload 31071 0x11/imm32/alloc-id:fake -31072 Single-float-var-in-some-register/imm32/next -31073 -31074 Single-int-var-in-some-register: # (payload list var) -31075 0x11/imm32/alloc-id:fake:payload -31076 0x11/imm32/alloc-id:fake -31077 Int-var-in-some-register/imm32 -31078 0/imm32/next -31079 0/imm32/next -31080 -31081 Single-addr-var-in-some-register: # (payload list var) -31082 0x11/imm32/alloc-id:fake:payload -31083 0x11/imm32/alloc-id:fake -31084 Addr-var-in-some-register/imm32 -31085 0/imm32/next -31086 0/imm32/next -31087 -31088 Single-byte-var-in-some-register: # (payload list var) +31072 _string-break-if-float>/imm32/name +31073 0x11/imm32/alloc-id:fake +31074 Single-lit-var/imm32/inouts +31075 0/imm32/no-outputs +31076 0/imm32/no-outputs +31077 0x11/imm32/alloc-id:fake +31078 _string_0f_87_jump_label/imm32/subx-name +31079 0/imm32/no-rm32 +31080 0/imm32/no-r32 +31081 0/imm32/no-imm32 +31082 0/imm32/no-imm8 +31083 1/imm32/disp32-is-first-inout +31084 0/imm32/no-xm32 +31085 0/imm32/no-x32 +31086 0x11/imm32/alloc-id:fake +31087 _Primitive-loop-if-float<-named/imm32/next +31088 _Primitive-loop-if-float<-named: # (payload primitive) 31089 0x11/imm32/alloc-id:fake:payload 31090 0x11/imm32/alloc-id:fake -31091 Byte-var-in-some-register/imm32 -31092 0/imm32/next -31093 0/imm32/next -31094 -31095 Int-var-in-some-register: # (payload var) -31096 0x11/imm32/alloc-id:fake:payload -31097 0/imm32/name -31098 0/imm32/name -31099 0x11/imm32/alloc-id:fake -31100 Type-int/imm32 -31101 1/imm32/some-block-depth -31102 0/imm32/no-stack-offset -31103 0x11/imm32/alloc-id:fake -31104 Any-register/imm32 -31105 -31106 Any-register: # (payload array byte) -31107 0x11/imm32/alloc-id:fake:payload -31108 1/imm32/size -31109 # data -31110 2a/asterisk -31111 -31112 Addr-var-in-some-register: # (payload var) -31113 0x11/imm32/alloc-id:fake:payload -31114 0/imm32/name -31115 0/imm32/name -31116 0x11/imm32/alloc-id:fake -31117 Type-addr/imm32 -31118 1/imm32/some-block-depth -31119 0/imm32/no-stack-offset -31120 0x11/imm32/alloc-id:fake -31121 Any-register/imm32 -31122 -31123 Byte-var-in-some-register: # (payload var) -31124 0x11/imm32/alloc-id:fake:payload -31125 0/imm32/name -31126 0/imm32/name -31127 0x11/imm32/alloc-id:fake -31128 Type-byte/imm32 -31129 1/imm32/some-block-depth -31130 0/imm32/no-stack-offset -31131 0x11/imm32/alloc-id:fake -31132 Any-register/imm32 -31133 -31134 Single-int-var-in-eax: # (payload list var) -31135 0x11/imm32/alloc-id:fake:payload -31136 0x11/imm32/alloc-id:fake -31137 Int-var-in-eax/imm32 -31138 0/imm32/next -31139 0/imm32/next -31140 -31141 Int-var-in-eax: -31142 0x11/imm32/alloc-id:fake:payload -31143 0/imm32/name -31144 0/imm32/name -31145 0x11/imm32/alloc-id:fake -31146 Type-int/imm32 -31147 1/imm32/some-block-depth -31148 0/imm32/no-stack-offset +31091 _string-loop-if-float</imm32/name +31092 0x11/imm32/alloc-id:fake +31093 Single-lit-var/imm32/inouts +31094 0/imm32/no-outputs +31095 0/imm32/no-outputs +31096 0x11/imm32/alloc-id:fake +31097 _string_0f_82_jump_label/imm32/subx-name +31098 0/imm32/no-rm32 +31099 0/imm32/no-r32 +31100 0/imm32/no-imm32 +31101 0/imm32/no-imm8 +31102 1/imm32/disp32-is-first-inout +31103 0/imm32/no-xm32 +31104 0/imm32/no-x32 +31105 0x11/imm32/alloc-id:fake +31106 _Primitive-loop-if-float>=-named/imm32/next +31107 _Primitive-loop-if-float>=-named: # (payload primitive) +31108 0x11/imm32/alloc-id:fake:payload +31109 0x11/imm32/alloc-id:fake +31110 _string-loop-if-float>=/imm32/name +31111 0x11/imm32/alloc-id:fake +31112 Single-lit-var/imm32/inouts +31113 0/imm32/no-outputs +31114 0/imm32/no-outputs +31115 0x11/imm32/alloc-id:fake +31116 _string_0f_83_jump_label/imm32/subx-name +31117 0/imm32/no-rm32 +31118 0/imm32/no-r32 +31119 0/imm32/no-imm32 +31120 0/imm32/no-imm8 +31121 1/imm32/disp32-is-first-inout +31122 0/imm32/no-xm32 +31123 0/imm32/no-x32 +31124 0x11/imm32/alloc-id:fake +31125 _Primitive-loop-if-float<=-named/imm32/next +31126 _Primitive-loop-if-float<=-named: # (payload primitive) +31127 0x11/imm32/alloc-id:fake:payload +31128 0x11/imm32/alloc-id:fake +31129 _string-loop-if-float<=/imm32/name +31130 0x11/imm32/alloc-id:fake +31131 Single-lit-var/imm32/inouts +31132 0/imm32/no-outputs +31133 0/imm32/no-outputs +31134 0x11/imm32/alloc-id:fake +31135 _string_0f_86_jump_label/imm32/subx-name +31136 0/imm32/no-rm32 +31137 0/imm32/no-r32 +31138 0/imm32/no-imm32 +31139 0/imm32/no-imm8 +31140 1/imm32/disp32-is-first-inout +31141 0/imm32/no-xm32 +31142 0/imm32/no-x32 +31143 0x11/imm32/alloc-id:fake +31144 _Primitive-loop-if-float>-named/imm32/next +31145 _Primitive-loop-if-float>-named: # (payload primitive) +31146 0x11/imm32/alloc-id:fake:payload +31147 0x11/imm32/alloc-id:fake +31148 _string-loop-if-float>/imm32/name 31149 0x11/imm32/alloc-id:fake -31150 $Mu-register-eax/imm32 # can't use Register-eax only to keep our buggy tools/treeshake.cc happy (TODO) -31151 -31152 Single-int-var-in-ecx: # (payload list var) -31153 0x11/imm32/alloc-id:fake:payload -31154 0x11/imm32/alloc-id:fake -31155 Int-var-in-ecx/imm32 -31156 0/imm32/next -31157 0/imm32/next -31158 -31159 Int-var-in-ecx: -31160 0x11/imm32/alloc-id:fake:payload -31161 0/imm32/name -31162 0/imm32/name -31163 0x11/imm32/alloc-id:fake -31164 Type-int/imm32 -31165 1/imm32/some-block-depth -31166 0/imm32/no-stack-offset -31167 0x11/imm32/alloc-id:fake -31168 $Register-ecx/imm32/register -31169 -31170 Single-int-var-in-edx: # (payload list var) -31171 0x11/imm32/alloc-id:fake:payload -31172 0x11/imm32/alloc-id:fake -31173 Int-var-in-edx/imm32 -31174 0/imm32/next -31175 0/imm32/next -31176 -31177 Int-var-in-edx: # (payload list var) -31178 0x11/imm32/alloc-id:fake:payload -31179 0/imm32/name -31180 0/imm32/name -31181 0x11/imm32/alloc-id:fake -31182 Type-int/imm32 -31183 1/imm32/some-block-depth -31184 0/imm32/no-stack-offset -31185 0x11/imm32/alloc-id:fake -31186 $Register-edx/imm32/register -31187 -31188 Single-int-var-in-ebx: # (payload list var) -31189 0x11/imm32/alloc-id:fake:payload -31190 0x11/imm32/alloc-id:fake -31191 Int-var-in-ebx/imm32 -31192 0/imm32/next -31193 0/imm32/next -31194 -31195 Int-var-in-ebx: # (payload list var) -31196 0x11/imm32/alloc-id:fake:payload -31197 0/imm32/name -31198 0/imm32/name -31199 0x11/imm32/alloc-id:fake -31200 Type-int/imm32 -31201 1/imm32/some-block-depth -31202 0/imm32/no-stack-offset -31203 0x11/imm32/alloc-id:fake -31204 $Register-ebx/imm32/register -31205 -31206 Single-int-var-in-esi: # (payload list var) +31150 Single-lit-var/imm32/inouts +31151 0/imm32/no-outputs +31152 0/imm32/no-outputs +31153 0x11/imm32/alloc-id:fake +31154 _string_0f_87_jump_label/imm32/subx-name +31155 0/imm32/no-rm32 +31156 0/imm32/no-r32 +31157 0/imm32/no-imm32 +31158 0/imm32/no-imm8 +31159 1/imm32/disp32-is-first-inout +31160 0/imm32/no-xm32 +31161 0/imm32/no-x32 +31162 0/imm32/next +31163 0/imm32/next +31164 +31165 # string literals for Mu instructions +31166 _string-add: # (payload array byte) +31167 0x11/imm32/alloc-id:fake:payload +31168 # "add" +31169 0x3/imm32/size +31170 0x61/a 0x64/d 0x64/d +31171 _string-address: # (payload array byte) +31172 0x11/imm32/alloc-id:fake:payload +31173 # "address" +31174 0x7/imm32/size +31175 0x61/a 0x64/d 0x64/d 0x72/r 0x65/e 0x73/s 0x73/s +31176 _string-add-to: # (payload array byte) +31177 0x11/imm32/alloc-id:fake:payload +31178 # "add-to" +31179 0x6/imm32/size +31180 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o +31181 _string-and: # (payload array byte) +31182 0x11/imm32/alloc-id:fake:payload +31183 # "and" +31184 0x3/imm32/size +31185 0x61/a 0x6e/n 0x64/d +31186 _string-and-with: # (payload array byte) +31187 0x11/imm32/alloc-id:fake:payload +31188 # "and-with" +31189 0x8/imm32/size +31190 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +31191 _string-break: # (payload array byte) +31192 0x11/imm32/alloc-id:fake:payload +31193 # "break" +31194 0x5/imm32/size +31195 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k +31196 _string-break-if-<: # (payload array byte) +31197 0x11/imm32/alloc-id:fake:payload +31198 # "break-if-<" +31199 0xa/imm32/size +31200 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< +31201 _string-break-if-<=: # (payload array byte) +31202 0x11/imm32/alloc-id:fake:payload +31203 # "break-if-<=" +31204 0xb/imm32/size +31205 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= +31206 _string-break-if-=: # (payload array byte) 31207 0x11/imm32/alloc-id:fake:payload -31208 0x11/imm32/alloc-id:fake -31209 Int-var-in-esi/imm32 -31210 0/imm32/next -31211 0/imm32/next -31212 -31213 Int-var-in-esi: # (payload list var) -31214 0x11/imm32/alloc-id:fake:payload -31215 0/imm32/name -31216 0/imm32/name -31217 0x11/imm32/alloc-id:fake -31218 Type-int/imm32 -31219 1/imm32/some-block-depth -31220 0/imm32/no-stack-offset -31221 0x11/imm32/alloc-id:fake -31222 $Register-esi/imm32/register -31223 -31224 Single-int-var-in-edi: # (payload list var) -31225 0x11/imm32/alloc-id:fake:payload -31226 0x11/imm32/alloc-id:fake -31227 Int-var-in-edi/imm32 -31228 0/imm32/next -31229 0/imm32/next -31230 -31231 Int-var-in-edi: # (payload list var) +31208 # "break-if-=" +31209 0xa/imm32/size +31210 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= +31211 _string-break-if->: # (payload array byte) +31212 0x11/imm32/alloc-id:fake:payload +31213 # "break-if->" +31214 0xa/imm32/size +31215 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> +31216 _string-break-if->=: # (payload array byte) +31217 0x11/imm32/alloc-id:fake:payload +31218 # "break-if->=" +31219 0xb/imm32/size +31220 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= +31221 _string-break-if-!=: # (payload array byte) +31222 0x11/imm32/alloc-id:fake:payload +31223 # "break-if-!=" +31224 0xb/imm32/size +31225 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= +31226 _string-break-if-addr<: # (payload array byte) +31227 0x11/imm32/alloc-id:fake:payload +31228 # "break-if-addr<" +31229 0xe/imm32/size +31230 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/< +31231 _string-break-if-addr<=: # (payload array byte) 31232 0x11/imm32/alloc-id:fake:payload -31233 0/imm32/name -31234 0/imm32/name -31235 0x11/imm32/alloc-id:fake -31236 Type-int/imm32 -31237 1/imm32/some-block-depth -31238 0/imm32/no-stack-offset -31239 0x11/imm32/alloc-id:fake -31240 $Register-edi/imm32/register -31241 -31242 Single-lit-var: # (payload list var) -31243 0x11/imm32/alloc-id:fake:payload -31244 0x11/imm32/alloc-id:fake -31245 Lit-var/imm32 -31246 0/imm32/next -31247 0/imm32/next -31248 -31249 Lit-var: # (payload var) -31250 0x11/imm32/alloc-id:fake:payload -31251 0/imm32/name -31252 0/imm32/name -31253 0x11/imm32/alloc-id:fake -31254 Type-literal/imm32 -31255 1/imm32/some-block-depth -31256 0/imm32/no-stack-offset -31257 0/imm32/no-register -31258 0/imm32/no-register -31259 -31260 Single-float-var-in-mem: # (payload list var) -31261 0x11/imm32/alloc-id:fake:payload -31262 0x11/imm32/alloc-id:fake -31263 Float-var-in-mem/imm32 -31264 0/imm32/next -31265 0/imm32/next -31266 -31267 Float-var-in-mem: # (payload var) -31268 0x11/imm32/alloc-id:fake:payload -31269 0/imm32/name -31270 0/imm32/name -31271 0x11/imm32/alloc-id:fake -31272 Type-float/imm32 -31273 1/imm32/some-block-depth -31274 1/imm32/some-stack-offset -31275 0/imm32/no-register -31276 0/imm32/no-register -31277 -31278 Single-float-var-in-some-register: # (payload list var) -31279 0x11/imm32/alloc-id:fake:payload -31280 0x11/imm32/alloc-id:fake -31281 Float-var-in-some-register/imm32 -31282 0/imm32/next -31283 0/imm32/next -31284 -31285 Float-var-in-some-register: # (payload var) -31286 0x11/imm32/alloc-id:fake:payload -31287 0/imm32/name -31288 0/imm32/name -31289 0x11/imm32/alloc-id:fake -31290 Type-float/imm32 -31291 1/imm32/some-block-depth -31292 0/imm32/no-stack-offset -31293 0x11/imm32/alloc-id:fake -31294 Any-register/imm32 -31295 -31296 Type-int: # (payload type-tree) +31233 # "break-if-addr<=" +31234 0xf/imm32/size +31235 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/= +31236 _string-break-if-addr>: # (payload array byte) +31237 0x11/imm32/alloc-id:fake:payload +31238 # "break-if-addr>" +31239 0xe/imm32/size +31240 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/> +31241 _string-break-if-addr>=: # (payload array byte) +31242 0x11/imm32/alloc-id:fake:payload +31243 # "break-if-addr>=" +31244 0xf/imm32/size +31245 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/= +31246 _string-break-if-float<: # (payload array byte) +31247 0x11/imm32/alloc-id:fake:payload +31248 # "break-if-float<" +31249 0xf/imm32/size +31250 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< +31251 _string-break-if-float<=: # (payload array byte) +31252 0x11/imm32/alloc-id:fake:payload +31253 # "break-if-float<=" +31254 0x10/imm32/size +31255 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< 0x3d/= +31256 _string-break-if-float>: # (payload array byte) +31257 0x11/imm32/alloc-id:fake:payload +31258 # "break-if-float>" +31259 0xf/imm32/size +31260 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> +31261 _string-break-if-float>=: # (payload array byte) +31262 0x11/imm32/alloc-id:fake:payload +31263 # "break-if-float>=" +31264 0x10/imm32/size +31265 0x62/b 0x72/r 0x65/e 0x61/a 0x6b/k 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> 0x3d/= +31266 _string-compare: # (payload array byte) +31267 0x11/imm32/alloc-id:fake:payload +31268 # "compare" +31269 0x7/imm32/size +31270 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e +31271 _string-copy: # (payload array byte) +31272 0x11/imm32/alloc-id:fake:payload +31273 # "copy" +31274 0x4/imm32/size +31275 0x63/c 0x6f/o 0x70/p 0x79/y +31276 _string-copy-to: # (payload array byte) +31277 0x11/imm32/alloc-id:fake:payload +31278 # "copy-to" +31279 0x7/imm32/size +31280 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/dash 0x74/t 0x6f/o +31281 _string-copy-byte: +31282 0x11/imm32/alloc-id:fake:payload +31283 # "copy-byte" +31284 0x9/imm32/size +31285 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e +31286 _string-copy-byte-to: +31287 0x11/imm32/alloc-id:fake:payload +31288 # "copy-byte-to" +31289 0xc/imm32/size +31290 0x63/c 0x6f/o 0x70/p 0x79/y 0x2d/- 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x74/t 0x6f/o +31291 _string-decrement: # (payload array byte) +31292 0x11/imm32/alloc-id:fake:payload +31293 # "decrement" +31294 0x9/imm32/size +31295 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t +31296 _string-increment: # (payload array byte) 31297 0x11/imm32/alloc-id:fake:payload -31298 1/imm32/is-atom -31299 1/imm32/value:int -31300 0/imm32/left:unused -31301 0/imm32/right:null -31302 0/imm32/right:null -31303 -31304 Type-literal: # (payload type-tree) -31305 0x11/imm32/alloc-id:fake:payload -31306 1/imm32/is-atom -31307 0/imm32/value:literal -31308 0/imm32/left:unused -31309 0/imm32/right:null -31310 0/imm32/right:null -31311 -31312 Type-addr: # (payload type-tree) -31313 0x11/imm32/alloc-id:fake:payload -31314 1/imm32/is-atom -31315 2/imm32/value:addr -31316 0/imm32/left:unused -31317 0/imm32/right:null -31318 0/imm32/right:null -31319 -31320 Type-byte: # (payload type-tree) -31321 0x11/imm32/alloc-id:fake:payload -31322 1/imm32/is-atom -31323 8/imm32/value:byte -31324 0/imm32/left:unused -31325 0/imm32/right:null -31326 0/imm32/right:null -31327 -31328 Type-float: # (payload type-tree) -31329 0x11/imm32/alloc-id:fake:payload -31330 1/imm32/is-atom -31331 0xf/imm32/value:float -31332 0/imm32/left:unused -31333 0/imm32/right:null -31334 0/imm32/right:null -31335 -31336 == code -31337 emit-subx-primitive: # out: (addr buffered-file), stmt: (addr stmt), primitive: (addr primitive), err: (addr buffered-file), ed: (addr exit-descriptor) -31338 # . prologue -31339 55/push-ebp -31340 89/<- %ebp 4/r32/esp -31341 # . save registers -31342 50/push-eax -31343 51/push-ecx -31344 # ecx = primitive -31345 8b/-> *(ebp+0x10) 1/r32/ecx -31346 # emit primitive name -31347 (emit-indent *(ebp+8) *Curr-block-depth) -31348 (lookup *(ecx+0x18) *(ecx+0x1c)) # Primitive-subx-name Primitive-subx-name => eax -31349 (write-buffered *(ebp+8) %eax) -31350 # emit rm32 if necessary -31351 (emit-subx-rm32 *(ebp+8) *(ecx+0x20) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-rm32 -31352 # emit xm32 if necessary -31353 (emit-subx-rm32 *(ebp+8) *(ecx+0x34) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-xm32 -31354 # emit r32 if necessary -31355 (emit-subx-r32 *(ebp+8) *(ecx+0x24) *(ebp+0xc)) # Primitive-subx-r32 -31356 # emit x32 if necessary -31357 (emit-subx-x32 *(ebp+8) *(ecx+0x38) *(ebp+0xc)) # Primitive-subx-x32 -31358 # emit imm32 if necessary -31359 (emit-subx-imm32 *(ebp+8) *(ecx+0x28) *(ebp+0xc)) # Primitive-subx-imm32 -31360 # emit imm8 if necessary -31361 (emit-subx-imm8 *(ebp+8) *(ecx+0x2c) *(ebp+0xc)) # Primitive-subx-imm8 -31362 # emit disp32 if necessary -31363 (emit-subx-disp32 *(ebp+8) *(ecx+0x30) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-disp32 -31364 (write-buffered *(ebp+8) Newline) -31365 $emit-subx-primitive:end: -31366 # . restore registers -31367 59/pop-to-ecx -31368 58/pop-to-eax -31369 # . epilogue -31370 89/<- %esp 5/r32/ebp -31371 5d/pop-to-ebp -31372 c3/return -31373 -31374 emit-subx-rm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -31375 # . prologue -31376 55/push-ebp -31377 89/<- %ebp 4/r32/esp -31378 # . save registers -31379 50/push-eax -31380 # if (l == 0) return -31381 81 7/subop/compare *(ebp+0xc) 0/imm32 -31382 74/jump-if-= $emit-subx-rm32:end/disp8 -31383 # var v/eax: (addr stmt-var) -31384 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # => eax -31385 (emit-subx-var-as-rm32 *(ebp+8) %eax) -31386 $emit-subx-rm32:end: -31387 # . restore registers -31388 58/pop-to-eax -31389 # . epilogue -31390 89/<- %esp 5/r32/ebp -31391 5d/pop-to-ebp -31392 c3/return -31393 -31394 get-stmt-operand-from-arg-location: # stmt: (addr stmt), l: arg-location, err: (addr buffered-file), ed: (addr exit-descriptor) -> var/eax: (addr stmt-var) -31395 # . prologue -31396 55/push-ebp -31397 89/<- %ebp 4/r32/esp -31398 # . save registers -31399 51/push-ecx -31400 # eax = l -31401 8b/-> *(ebp+0xc) 0/r32/eax -31402 # ecx = stmt -31403 8b/-> *(ebp+8) 1/r32/ecx -31404 # if (l == 1) return stmt->inouts -31405 { -31406 3d/compare-eax-and 1/imm32 -31407 75/jump-if-!= break/disp8 -31408 $get-stmt-operand-from-arg-location:1: -31409 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -31410 eb/jump $get-stmt-operand-from-arg-location:end/disp8 -31411 } -31412 # if (l == 2) return stmt->inouts->next -31413 { -31414 3d/compare-eax-and 2/imm32 -31415 75/jump-if-!= break/disp8 -31416 $get-stmt-operand-from-arg-location:2: -31417 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -31418 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -31419 eb/jump $get-stmt-operand-from-arg-location:end/disp8 -31420 } -31421 # if (l == 3) return stmt->outputs -31422 { -31423 3d/compare-eax-and 3/imm32 -31424 75/jump-if-!= break/disp8 -31425 $get-stmt-operand-from-arg-location:3: -31426 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -31427 eb/jump $get-stmt-operand-from-arg-location:end/disp8 -31428 } -31429 # abort -31430 e9/jump $get-stmt-operand-from-arg-location:abort/disp32 -31431 $get-stmt-operand-from-arg-location:end: -31432 # . restore registers -31433 59/pop-to-ecx -31434 # . epilogue -31435 89/<- %esp 5/r32/ebp -31436 5d/pop-to-ebp -31437 c3/return -31438 -31439 $get-stmt-operand-from-arg-location:abort: -31440 # error("invalid arg-location " eax) -31441 (write-buffered *(ebp+0x10) "invalid arg-location ") -31442 (write-int32-hex-buffered *(ebp+0x10) %eax) -31443 (write-buffered *(ebp+0x10) Newline) -31444 (flush *(ebp+0x10)) -31445 (stop *(ebp+0x14) 1) -31446 # never gets here -31447 -31448 emit-subx-r32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -31449 # . prologue -31450 55/push-ebp -31451 89/<- %ebp 4/r32/esp -31452 # . save registers -31453 50/push-eax -31454 51/push-ecx -31455 # if (l == 0) return -31456 81 7/subop/compare *(ebp+0xc) 0/imm32 -31457 0f 84/jump-if-= $emit-subx-r32:end/disp32 -31458 # var v/eax: (addr stmt-var) -31459 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -31460 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -31461 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -31462 #? (write-buffered Stderr "looking up ") -31463 #? (write-buffered Stderr %eax) -31464 #? (write-buffered Stderr Newline) -31465 #? (flush Stderr) -31466 (maybe-get Mu-registers %eax 0xc) # => eax: (addr register-index) -31467 (write-buffered *(ebp+8) Space) -31468 (write-int32-hex-buffered *(ebp+8) *eax) -31469 (write-buffered *(ebp+8) "/r32") -31470 $emit-subx-r32:end: -31471 # . restore registers -31472 59/pop-to-ecx -31473 58/pop-to-eax -31474 # . epilogue -31475 89/<- %esp 5/r32/ebp -31476 5d/pop-to-ebp -31477 c3/return -31478 -31479 emit-subx-x32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -31480 # . prologue -31481 55/push-ebp -31482 89/<- %ebp 4/r32/esp -31483 # . save registers -31484 50/push-eax -31485 51/push-ecx -31486 # if (l == 0) return -31487 81 7/subop/compare *(ebp+0xc) 0/imm32 -31488 0f 84/jump-if-= $emit-subx-x32:end/disp32 -31489 # var v/eax: (addr stmt-var) -31490 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -31491 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -31492 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax -31493 #? (write-buffered Stderr "looking up ") -31494 #? (write-buffered Stderr %eax) -31495 #? (write-buffered Stderr Newline) -31496 #? (flush Stderr) -31497 (maybe-get Mu-registers %eax 0xc) # => eax: (addr register-index) -31498 (write-buffered *(ebp+8) Space) -31499 (write-int32-hex-buffered *(ebp+8) *eax) -31500 (write-buffered *(ebp+8) "/x32") -31501 $emit-subx-x32:end: -31502 # . restore registers -31503 59/pop-to-ecx -31504 58/pop-to-eax -31505 # . epilogue -31506 89/<- %esp 5/r32/ebp -31507 5d/pop-to-ebp -31508 c3/return -31509 -31510 emit-subx-imm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -31511 # . prologue -31512 55/push-ebp -31513 89/<- %ebp 4/r32/esp -31514 # . save registers -31515 50/push-eax -31516 51/push-ecx -31517 # if (l == 0) return -31518 81 7/subop/compare *(ebp+0xc) 0/imm32 -31519 0f 84/jump-if-= $emit-subx-imm32:end/disp32 -31520 # var v/eax: (handle var) -31521 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -31522 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -31523 (lookup *eax *(eax+4)) # Var-name Var-name => eax -31524 (write-buffered *(ebp+8) Space) -31525 (write-buffered *(ebp+8) %eax) -31526 (write-buffered *(ebp+8) "/imm32") -31527 $emit-subx-imm32:end: -31528 # . restore registers -31529 59/pop-to-ecx -31530 58/pop-to-eax -31531 # . epilogue -31532 89/<- %esp 5/r32/ebp -31533 5d/pop-to-ebp -31534 c3/return -31535 -31536 emit-subx-imm8: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) -31537 # . prologue -31538 55/push-ebp -31539 89/<- %ebp 4/r32/esp -31540 # . save registers -31541 50/push-eax -31542 51/push-ecx -31543 # if (l == 0) return -31544 81 7/subop/compare *(ebp+0xc) 0/imm32 -31545 0f 84/jump-if-= $emit-subx-imm32:end/disp32 -31546 # var v/eax: (handle var) -31547 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax -31548 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -31549 (lookup *eax *(eax+4)) # Var-name Var-name => eax -31550 (write-buffered *(ebp+8) Space) -31551 (write-buffered *(ebp+8) %eax) -31552 (write-buffered *(ebp+8) "/imm8") -31553 $emit-subx-imm8:end: -31554 # . restore registers -31555 59/pop-to-ecx -31556 58/pop-to-eax -31557 # . epilogue -31558 89/<- %esp 5/r32/ebp -31559 5d/pop-to-ebp -31560 c3/return -31561 -31562 emit-subx-disp32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) -31563 # . prologue -31564 55/push-ebp -31565 89/<- %ebp 4/r32/esp -31566 # . save registers -31567 50/push-eax -31568 51/push-ecx -31569 # if (location == 0) return -31570 81 7/subop/compare *(ebp+0xc) 0/imm32 -31571 0f 84/jump-if-= $emit-subx-disp32:end/disp32 -31572 # var v/eax: (addr stmt-var) -31573 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # => eax -31574 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax -31575 (lookup *eax *(eax+4)) # Var-name Var-name => eax -31576 (write-buffered *(ebp+8) Space) -31577 (write-buffered *(ebp+8) %eax) -31578 # hack: if instruction operation starts with "break", emit ":break" -31579 # var name/ecx: (addr array byte) = lookup(stmt->operation) -31580 8b/-> *(ebp+0x10) 0/r32/eax -31581 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -31582 89/<- %ecx 0/r32/eax -31583 { -31584 (string-starts-with? %ecx "break") # => eax -31585 3d/compare-eax-and 0/imm32/false -31586 74/jump-if-= break/disp8 -31587 (write-buffered *(ebp+8) ":break") -31588 } -31589 # hack: if instruction operation starts with "loop", emit ":loop" -31590 { -31591 (string-starts-with? %ecx "loop") # => eax -31592 3d/compare-eax-and 0/imm32/false -31593 74/jump-if-= break/disp8 -31594 (write-buffered *(ebp+8) ":loop") -31595 } -31596 (write-buffered *(ebp+8) "/disp32") -31597 $emit-subx-disp32:end: -31598 # . restore registers -31599 59/pop-to-ecx -31600 58/pop-to-eax -31601 # . epilogue -31602 89/<- %esp 5/r32/ebp -31603 5d/pop-to-ebp -31604 c3/return -31605 -31606 emit-call: # out: (addr buffered-file), stmt: (addr stmt) -31607 # . prologue -31608 55/push-ebp -31609 89/<- %ebp 4/r32/esp -31610 # . save registers -31611 50/push-eax -31612 51/push-ecx -31613 # -31614 (emit-indent *(ebp+8) *Curr-block-depth) -31615 (write-buffered *(ebp+8) "(") -31616 # ecx = stmt -31617 8b/-> *(ebp+0xc) 1/r32/ecx -31618 # - emit function name -31619 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -31620 (write-buffered *(ebp+8) %eax) -31621 # - emit arguments -31622 # var curr/eax: (addr stmt-var) = lookup(stmt->inouts) -31623 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -31624 { -31625 # if (curr == null) break -31626 3d/compare-eax-and 0/imm32 -31627 74/jump-if-= break/disp8 -31628 # -31629 (emit-subx-call-operand *(ebp+8) %eax) -31630 # curr = lookup(curr->next) -31631 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax -31632 eb/jump loop/disp8 -31633 } -31634 # -31635 (write-buffered *(ebp+8) ")\n") -31636 $emit-call:end: -31637 # . restore registers -31638 59/pop-to-ecx -31639 58/pop-to-eax -31640 # . epilogue -31641 89/<- %esp 5/r32/ebp -31642 5d/pop-to-ebp -31643 c3/return -31644 -31645 emit-subx-call-operand: # out: (addr buffered-file), s: (addr stmt-var) -31646 # shares code with emit-subx-var-as-rm32 -31647 # . prologue -31648 55/push-ebp -31649 89/<- %ebp 4/r32/esp -31650 # . save registers -31651 50/push-eax -31652 51/push-ecx -31653 56/push-esi -31654 # ecx = s -31655 8b/-> *(ebp+0xc) 1/r32/ecx -31656 # var operand/esi: (addr var) = lookup(s->value) -31657 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -31658 89/<- %esi 0/r32/eax -31659 # if (operand->register && !s->is-deref?) emit "%__" -31660 { -31661 $emit-subx-call-operand:check-for-register-direct: -31662 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -31663 74/jump-if-= break/disp8 -31664 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -31665 75/jump-if-!= break/disp8 -31666 $emit-subx-call-operand:register-direct: -31667 (write-buffered *(ebp+8) " %") -31668 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -31669 (write-buffered *(ebp+8) %eax) -31670 e9/jump $emit-subx-call-operand:end/disp32 -31671 } -31672 # else if (operand->register && s->is-deref?) emit "*__" -31673 { -31674 $emit-subx-call-operand:check-for-register-indirect: -31675 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -31676 74/jump-if-= break/disp8 -31677 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -31678 74/jump-if-= break/disp8 -31679 $emit-subx-call-operand:register-indirect: -31680 (emit-subx-call-operand-register-indirect *(ebp+8) %esi) -31681 e9/jump $emit-subx-call-operand:end/disp32 -31682 } -31683 # else if (operand->stack-offset) emit "*(ebp+__)" -31684 { -31685 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset -31686 74/jump-if-= break/disp8 -31687 $emit-subx-call-operand:stack: -31688 (emit-subx-call-operand-stack *(ebp+8) %esi) -31689 e9/jump $emit-subx-call-operand:end/disp32 -31690 } -31691 # else if (operand->type == literal) emit "__" -31692 { -31693 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax -31694 81 7/subop/compare *(eax+4) 0/imm32 # Type-tree-value -31695 75/jump-if-!= break/disp8 -31696 $emit-subx-call-operand:literal: -31697 (write-buffered *(ebp+8) Space) -31698 (lookup *esi *(esi+4)) # Var-name Var-name => eax -31699 (write-buffered *(ebp+8) %eax) -31700 e9/jump $emit-subx-call-operand:end/disp32 -31701 } -31702 # else if (operand->type == literal-string) emit "__" -31703 { -31704 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax -31705 81 7/subop/compare *(eax+4) 0x10/imm32 # Type-tree-value -31706 75/jump-if-!= break/disp8 -31707 $emit-subx-call-operand:literal-string: -31708 (write-buffered *(ebp+8) Space) -31709 (lookup *esi *(esi+4)) # Var-name Var-name => eax -31710 (write-buffered *(ebp+8) %eax) -31711 } -31712 $emit-subx-call-operand:end: -31713 # . restore registers -31714 5e/pop-to-esi -31715 59/pop-to-ecx -31716 58/pop-to-eax -31717 # . epilogue -31718 89/<- %esp 5/r32/ebp -31719 5d/pop-to-ebp -31720 c3/return -31721 -31722 emit-subx-call-operand-register-indirect: # out: (addr buffered-file), v: (addr var) -31723 # . prologue -31724 55/push-ebp -31725 89/<- %ebp 4/r32/esp -31726 # . save registers -31727 50/push-eax -31728 51/push-ecx -31729 56/push-esi -31730 # esi = v -31731 8b/-> *(ebp+0xc) 6/r32/esi -31732 # var size/ecx: int = size-of-deref(v) -31733 (size-of-deref %esi) # => eax -31734 89/<- %ecx 0/r32/eax -31735 # var reg-name/esi: (addr array byte) = lookup(v->register) -31736 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -31737 89/<- %esi 0/r32/eax -31738 # TODO: assert size is a multiple of 4 -31739 # var i/eax: int = 0 -31740 b8/copy-to-eax 0/imm32 -31741 { -31742 $emit-subx-call-operand-register-indirect:loop: -31743 # if (i >= size) break -31744 39/compare %eax 1/r32/ecx -31745 7d/jump-if->= break/disp8 -31746 # emit " *(" v->register "+" i ")" -31747 (write-buffered *(ebp+8) " *(") -31748 (write-buffered *(ebp+8) %esi) -31749 (write-buffered *(ebp+8) "+") -31750 (write-int32-hex-buffered *(ebp+8) %eax) -31751 (write-buffered *(ebp+8) ")") -31752 # i += 4 -31753 05/add-to-eax 4/imm32 -31754 # -31755 eb/jump loop/disp8 -31756 } -31757 $emit-subx-call-operand-register-indirect:end: -31758 # . restore registers -31759 5e/pop-to-esi -31760 59/pop-to-ecx -31761 58/pop-to-eax -31762 # . epilogue -31763 89/<- %esp 5/r32/ebp -31764 5d/pop-to-ebp -31765 c3/return -31766 -31767 emit-subx-call-operand-stack: # out: (addr buffered-file), v: (addr var) -31768 # . prologue -31769 55/push-ebp -31770 89/<- %ebp 4/r32/esp -31771 # . save registers -31772 50/push-eax -31773 51/push-ecx -31774 56/push-esi -31775 # esi = v -31776 8b/-> *(ebp+0xc) 6/r32/esi -31777 # var curr/ecx: int = v->offset -31778 8b/-> *(esi+0x14) 1/r32/ecx # Var-offset -31779 # var max/eax: int = v->offset + size-of(v) -31780 (size-of %esi) # => eax -31781 # TODO: assert size is a multiple of 4 -31782 01/add-to %eax 1/r32/ecx -31783 { -31784 $emit-subx-call-operand-stack:loop: -31785 # if (curr >= max) break -31786 39/compare %ecx 0/r32/eax -31787 7d/jump-if->= break/disp8 -31788 # emit " *(ebp+" curr ")" -31789 (write-buffered *(ebp+8) " *(ebp+") -31790 (write-int32-hex-buffered *(ebp+8) %ecx) -31791 (write-buffered *(ebp+8) ")") -31792 # i += 4 -31793 81 0/subop/add %ecx 4/imm32 -31794 # -31795 eb/jump loop/disp8 -31796 } -31797 $emit-subx-call-operand-stack:end: -31798 # . restore registers -31799 5e/pop-to-esi -31800 59/pop-to-ecx -31801 58/pop-to-eax -31802 # . epilogue -31803 89/<- %esp 5/r32/ebp -31804 5d/pop-to-ebp -31805 c3/return -31806 -31807 emit-subx-var-as-rm32: # out: (addr buffered-file), s: (addr stmt-var) -31808 # . prologue -31809 55/push-ebp -31810 89/<- %ebp 4/r32/esp -31811 # . save registers -31812 50/push-eax -31813 51/push-ecx -31814 56/push-esi -31815 # ecx = s -31816 8b/-> *(ebp+0xc) 1/r32/ecx -31817 # var operand/esi: (addr var) = lookup(s->value) -31818 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -31819 89/<- %esi 0/r32/eax -31820 # if (operand->register && s->is-deref?) emit "*__" -31821 { -31822 $emit-subx-var-as-rm32:check-for-register-indirect: -31823 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -31824 74/jump-if-= break/disp8 -31825 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -31826 74/jump-if-= break/disp8 -31827 $emit-subx-var-as-rm32:register-indirect: -31828 (write-buffered *(ebp+8) " *") -31829 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -31830 (write-buffered *(ebp+8) %eax) -31831 e9/jump $emit-subx-var-as-rm32:end/disp32 -31832 } -31833 # if (operand->register && !s->is-deref?) emit "%__" -31834 { -31835 $emit-subx-var-as-rm32:check-for-register-direct: -31836 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -31837 74/jump-if-= break/disp8 -31838 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -31839 75/jump-if-!= break/disp8 -31840 $emit-subx-var-as-rm32:register-direct: -31841 (write-buffered *(ebp+8) " %") -31842 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -31843 (write-buffered *(ebp+8) %eax) -31844 e9/jump $emit-subx-var-as-rm32:end/disp32 -31845 } -31846 # else if (operand->stack-offset) emit "*(ebp+__)" -31847 { -31848 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset -31849 74/jump-if-= break/disp8 -31850 $emit-subx-var-as-rm32:stack: -31851 (write-buffered *(ebp+8) Space) -31852 (write-buffered *(ebp+8) "*(ebp+") -31853 (write-int32-hex-buffered *(ebp+8) *(esi+0x14)) # Var-offset -31854 (write-buffered *(ebp+8) ")") -31855 } -31856 $emit-subx-var-as-rm32:end: -31857 # . restore registers -31858 5e/pop-to-esi -31859 59/pop-to-ecx -31860 58/pop-to-eax -31861 # . epilogue -31862 89/<- %esp 5/r32/ebp -31863 5d/pop-to-ebp -31864 c3/return -31865 -31866 find-matching-primitive: # primitives: (addr primitive), stmt: (addr stmt) -> result/eax: (addr primitive) -31867 # . prologue -31868 55/push-ebp -31869 89/<- %ebp 4/r32/esp -31870 # . save registers -31871 51/push-ecx -31872 # var curr/ecx: (addr primitive) = primitives -31873 8b/-> *(ebp+8) 1/r32/ecx -31874 { -31875 $find-matching-primitive:loop: -31876 # if (curr == null) break -31877 81 7/subop/compare %ecx 0/imm32 -31878 74/jump-if-= break/disp8 -31879 # if match(curr, stmt) return curr -31880 { -31881 (mu-stmt-matches-primitive? *(ebp+0xc) %ecx) # => eax -31882 3d/compare-eax-and 0/imm32/false -31883 74/jump-if-= break/disp8 -31884 89/<- %eax 1/r32/ecx -31885 eb/jump $find-matching-primitive:end/disp8 -31886 } -31887 $find-matching-primitive:next-primitive: -31888 # curr = curr->next -31889 (lookup *(ecx+0x3c) *(ecx+0x40)) # Primitive-next Primitive-next => eax -31890 89/<- %ecx 0/r32/eax -31891 # -31892 e9/jump loop/disp32 -31893 } -31894 # return null -31895 b8/copy-to-eax 0/imm32 -31896 $find-matching-primitive:end: -31897 # . restore registers -31898 59/pop-to-ecx -31899 # . epilogue -31900 89/<- %esp 5/r32/ebp -31901 5d/pop-to-ebp -31902 c3/return -31903 -31904 mu-stmt-matches-primitive?: # stmt: (addr stmt), primitive: (addr primitive) -> result/eax: boolean -31905 # A mu stmt matches a primitive if the name matches, all the inout vars -31906 # match, and all the output vars match. -31907 # Vars match if types match and registers match. -31908 # In addition, a stmt output matches a primitive's output if types match -31909 # and the primitive has a wildcard register. -31910 # . prologue -31911 55/push-ebp -31912 89/<- %ebp 4/r32/esp -31913 # . save registers -31914 51/push-ecx -31915 52/push-edx -31916 53/push-ebx -31917 56/push-esi -31918 57/push-edi -31919 # ecx = stmt -31920 8b/-> *(ebp+8) 1/r32/ecx -31921 # edx = primitive -31922 8b/-> *(ebp+0xc) 2/r32/edx -31923 { -31924 $mu-stmt-matches-primitive?:check-name: -31925 # if (primitive->name != stmt->operation) return false -31926 # . var esi: (addr array byte) = lookup(stmt->operation) -31927 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax -31928 89/<- %esi 0/r32/eax -31929 # . var edi: (addr array byte) = lookup(primitive->name) -31930 (lookup *edx *(edx+4)) # Primitive-name Primitive-name => eax -31931 #? (write-buffered Stderr %eax) -31932 #? (write-buffered Stderr Newline) -31933 #? (flush Stderr) -31934 89/<- %edi 0/r32/eax -31935 (string-equal? %esi %edi) # => eax -31936 3d/compare-eax-and 0/imm32/false -31937 75/jump-if-!= break/disp8 -31938 b8/copy-to-eax 0/imm32 -31939 e9/jump $mu-stmt-matches-primitive?:end/disp32 -31940 } -31941 # var curr/esi: (addr stmt-var) = lookup(stmt->inouts) -31942 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax -31943 89/<- %esi 0/r32/eax -31944 # var curr2/edi: (addr list var) = lookup(primitive->inouts) -31945 (lookup *(edx+8) *(edx+0xc)) # Primitive-inouts Primitive-inouts => eax -31946 89/<- %edi 0/r32/eax -31947 { -31948 $mu-stmt-matches-primitive?:inouts-loop: -31949 # if (curr == 0 && curr2 == 0) move on to check outputs -31950 { -31951 $mu-stmt-matches-primitive?:check-both-inouts-null: -31952 81 7/subop/compare %esi 0/imm32 -31953 75/jump-if-!= break/disp8 -31954 $mu-stmt-matches-primitive?:stmt-inout-null: -31955 81 7/subop/compare %edi 0/imm32 -31956 0f 84/jump-if-= $mu-stmt-matches-primitive?:check-outputs/disp32 -31957 $mu-stmt-matches-primitive?:stmt-inout-null-and-prim-inout-not-null: -31958 # return false -31959 b8/copy-to-eax 0/imm32/false -31960 e9/jump $mu-stmt-matches-primitive?:end/disp32 -31961 } -31962 # if (curr2 == 0) return false -31963 { -31964 $mu-stmt-matches-primitive?:check-prim-inout-null: -31965 81 7/subop/compare %edi 0/imm32 -31966 75/jump-if-!= break/disp8 -31967 $mu-stmt-matches-primitive?:prim-inout-null: -31968 b8/copy-to-eax 0/imm32/false -31969 e9/jump $mu-stmt-matches-primitive?:end/disp32 -31970 } -31971 # if (curr != curr2) return false -31972 { -31973 $mu-stmt-matches-primitive?:check-inouts-match: -31974 (lookup *edi *(edi+4)) # List-value List-value => eax -31975 (operand-matches-primitive? %esi %eax) # => eax -31976 3d/compare-eax-and 0/imm32/false -31977 75/jump-if-!= break/disp8 -31978 $mu-stmt-matches-primitive?:inouts-match: -31979 b8/copy-to-eax 0/imm32/false -31980 e9/jump $mu-stmt-matches-primitive?:end/disp32 -31981 } -31982 $mu-stmt-matches-primitive?:next-inout: -31983 # curr = lookup(curr->next) -31984 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -31985 89/<- %esi 0/r32/eax -31986 # curr2 = lookup(curr2->next) -31987 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax -31988 89/<- %edi 0/r32/eax -31989 # -31990 e9/jump loop/disp32 -31991 } -31992 $mu-stmt-matches-primitive?:check-outputs: -31993 # var curr/esi: (addr stmt-var) = lookup(stmt->outputs) -31994 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax -31995 89/<- %esi 0/r32/eax -31996 # var curr2/edi: (addr list var) = lookup(primitive->outputs) -31997 (lookup *(edx+0x10) *(edx+0x14)) # Primitive-outputs Primitive-outputs => eax -31998 89/<- %edi 0/r32/eax -31999 { -32000 $mu-stmt-matches-primitive?:outputs-loop: -32001 # if (curr == 0) return (curr2 == 0) -32002 { -32003 $mu-stmt-matches-primitive?:check-both-outputs-null: -32004 81 7/subop/compare %esi 0/imm32 -32005 75/jump-if-!= break/disp8 -32006 { -32007 $mu-stmt-matches-primitive?:stmt-output-null: -32008 81 7/subop/compare %edi 0/imm32 -32009 75/jump-if-!= break/disp8 -32010 $mu-stmt-matches-primitive?:both-outputs-null: -32011 # return true -32012 b8/copy-to-eax 1/imm32 -32013 e9/jump $mu-stmt-matches-primitive?:end/disp32 -32014 } -32015 $mu-stmt-matches-primitive?:stmt-output-null-and-prim-output-not-null: -32016 # return false -32017 b8/copy-to-eax 0/imm32 -32018 e9/jump $mu-stmt-matches-primitive?:end/disp32 -32019 } -32020 # if (curr2 == 0) return false -32021 { -32022 $mu-stmt-matches-primitive?:check-prim-output-null: -32023 81 7/subop/compare %edi 0/imm32 -32024 75/jump-if-!= break/disp8 -32025 $mu-stmt-matches-primitive?:prim-output-is-null: -32026 b8/copy-to-eax 0/imm32 -32027 e9/jump $mu-stmt-matches-primitive?:end/disp32 -32028 } -32029 # if (curr != curr2) return false -32030 { -32031 $mu-stmt-matches-primitive?:check-outputs-match: -32032 (lookup *edi *(edi+4)) # List-value List-value => eax -32033 (operand-matches-primitive? %esi %eax) # => eax -32034 3d/compare-eax-and 0/imm32/false -32035 75/jump-if-!= break/disp8 -32036 $mu-stmt-matches-primitive?:outputs-match: -32037 b8/copy-to-eax 0/imm32 -32038 e9/jump $mu-stmt-matches-primitive?:end/disp32 -32039 } -32040 $mu-stmt-matches-primitive?:next-output: -32041 # curr = lookup(curr->next) -32042 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax -32043 89/<- %esi 0/r32/eax -32044 # curr2 = lookup(curr2->next) -32045 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax -32046 89/<- %edi 0/r32/eax -32047 # -32048 e9/jump loop/disp32 -32049 } -32050 $mu-stmt-matches-primitive?:return-true: -32051 b8/copy-to-eax 1/imm32 -32052 $mu-stmt-matches-primitive?:end: -32053 # . restore registers -32054 5f/pop-to-edi -32055 5e/pop-to-esi -32056 5b/pop-to-ebx -32057 5a/pop-to-edx -32058 59/pop-to-ecx -32059 # . epilogue -32060 89/<- %esp 5/r32/ebp -32061 5d/pop-to-ebp -32062 c3/return -32063 -32064 operand-matches-primitive?: # s: (addr stmt-var), prim-var: (addr var) -> result/eax: boolean -32065 # . prologue -32066 55/push-ebp -32067 89/<- %ebp 4/r32/esp -32068 # . save registers -32069 51/push-ecx -32070 52/push-edx -32071 53/push-ebx -32072 56/push-esi -32073 57/push-edi -32074 # ecx = s -32075 8b/-> *(ebp+8) 1/r32/ecx -32076 # var var/esi: (addr var) = lookup(s->value) -32077 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax -32078 89/<- %esi 0/r32/eax -32079 # edi = prim-var -32080 8b/-> *(ebp+0xc) 7/r32/edi -32081 $operand-matches-primitive?:check-type: -32082 # if !category-match?(var->type, prim-var->type) return false -32083 # . var vtype/ebx: (addr type-tree) = lookup(var->type) -32084 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax -32085 89/<- %ebx 0/r32/eax -32086 # . if s is deref, vtype = vtype->right -32087 { -32088 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -32089 74/jump-if-= break/disp8 -32090 $operand-matches-primitive?:is-deref: -32091 # . var t/eax: (addr type) -32092 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax -32093 # . if !t->is-atom? t = t->left -32094 81 7/subop/compare *eax 0/imm32/false -32095 { -32096 75/jump-if-!= break/disp8 -32097 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -32098 } -32099 # . -32100 89/<- %ebx 0/r32/eax -32101 } -32102 # . var ptype/eax: (addr type-tree) = lookup(prim-var->type) -32103 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax -32104 (subx-type-category-match? %ebx %eax) # => eax -32105 3d/compare-eax-and 0/imm32/false -32106 0f 84/jump-if-= $operand-matches-primitive?:return-false/disp32 -32107 { -32108 $operand-matches-primitive?:check-register: -32109 # if prim-var is in memory and var is in register but dereference, match -32110 { -32111 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register -32112 0f 85/jump-if-!= break/disp32 -32113 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -32114 74/jump-if-= break/disp8 -32115 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -32116 74/jump-if-= break/disp8 -32117 $operand-matches-primitive?:var-deref-match: -32118 e9/jump $operand-matches-primitive?:return-true/disp32 -32119 } -32120 # if prim-var is in register and var is in register but dereference, no match -32121 { -32122 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register -32123 0f 84/jump-if-= break/disp32 -32124 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register -32125 0f 84/jump-if-= break/disp32 -32126 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref -32127 74/jump-if-= break/disp8 -32128 $operand-matches-primitive?:var-deref-no-match: -32129 e9/jump $operand-matches-primitive?:return-false/disp32 -32130 } -32131 # return false if var->register doesn't match prim-var->register -32132 { -32133 # if register addresses are equal, it's a match -32134 # var vreg/ebx: (addr array byte) = lookup(var->register) -32135 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax -32136 89/<- %ebx 0/r32/eax -32137 # var preg/ecx: (addr array byte) = lookup(prim-var->register) -32138 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax -32139 89/<- %ecx 0/r32/eax -32140 # if (vreg == preg) break -32141 39/compare %ecx 3/r32/ebx -32142 74/jump-if-= break/disp8 -32143 $operand-matches-primitive?:var-register-no-match: -32144 # if either address is 0, return false -32145 81 7/subop/compare %ebx 0/imm32 -32146 74/jump-if-= $operand-matches-primitive?:return-false/disp8 -32147 81 7/subop/compare %ecx 0/imm32 -32148 74/jump-if-= $operand-matches-primitive?:return-false/disp8 -32149 # if prim-var->register is wildcard, it's a match -32150 (string-equal? %ecx "*") # Any-register => eax -32151 3d/compare-eax-and 0/imm32/false -32152 75/jump-if-!= break/disp8 -32153 $operand-matches-primitive?:wildcard-no-match: -32154 # if string contents aren't equal, return false -32155 (string-equal? %ecx %ebx) # => eax -32156 3d/compare-eax-and 0/imm32/false -32157 74/jump-if-= $operand-matches-primitive?:return-false/disp8 -32158 } -32159 } -32160 $operand-matches-primitive?:return-true: -32161 b8/copy-to-eax 1/imm32/true -32162 eb/jump $operand-matches-primitive?:end/disp8 -32163 $operand-matches-primitive?:return-false: -32164 b8/copy-to-eax 0/imm32/false -32165 $operand-matches-primitive?:end: -32166 # . restore registers -32167 5f/pop-to-edi -32168 5e/pop-to-esi -32169 5b/pop-to-ebx -32170 5a/pop-to-edx -32171 59/pop-to-ecx -32172 # . epilogue -32173 89/<- %esp 5/r32/ebp -32174 5d/pop-to-ebp -32175 c3/return -32176 -32177 find-matching-function: # functions: (addr function), stmt: (addr stmt) -> result/eax: (addr function) -32178 # . prologue -32179 55/push-ebp -32180 89/<- %ebp 4/r32/esp -32181 # . save registers -32182 51/push-ecx -32183 # var curr/ecx: (handle function) = functions -32184 8b/-> *(ebp+8) 1/r32/ecx -32185 { -32186 # if (curr == null) break -32187 81 7/subop/compare %ecx 0/imm32 -32188 74/jump-if-= break/disp8 -32189 #? (write-buffered Stderr "iter\n") -32190 #? (flush Stderr) -32191 # if match(stmt, curr) return curr -32192 { -32193 (mu-stmt-matches-function? *(ebp+0xc) %ecx) # => eax -32194 3d/compare-eax-and 0/imm32/false -32195 74/jump-if-= break/disp8 -32196 89/<- %eax 1/r32/ecx -32197 eb/jump $find-matching-function:end/disp8 -32198 } -32199 # curr = curr->next -32200 (lookup *(ecx+0x20) *(ecx+0x24)) # Function-next Function-next => eax -32201 89/<- %ecx 0/r32/eax -32202 # -32203 eb/jump loop/disp8 -32204 } -32205 # return null -32206 b8/copy-to-eax 0/imm32 -32207 $find-matching-function:end: -32208 # . restore registers -32209 59/pop-to-ecx -32210 # . epilogue -32211 89/<- %esp 5/r32/ebp -32212 5d/pop-to-ebp -32213 c3/return -32214 -32215 # Just compare names; user-defined functions don't support overloading yet. -32216 mu-stmt-matches-function?: # stmt: (addr stmt1), function: (addr function) -> result/eax: boolean -32217 # . prologue -32218 55/push-ebp -32219 89/<- %ebp 4/r32/esp -32220 # . save registers -32221 51/push-ecx -32222 # return function->name == stmt->operation -32223 # ecx = lookup(stmt->operation) -32224 8b/-> *(ebp+8) 0/r32/eax -32225 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax -32226 89/<- %ecx 0/r32/eax -32227 # eax = lookup(function->name) -32228 8b/-> *(ebp+0xc) 0/r32/eax -32229 (lookup *eax *(eax+4)) # Function-name Function-name => eax -32230 (string-equal? %eax %ecx) # => eax -32231 $mu-stmt-matches-function?:end: -32232 # . restore registers -32233 59/pop-to-ecx -32234 # . epilogue -32235 89/<- %esp 5/r32/ebp -32236 5d/pop-to-ebp -32237 c3/return -32238 -32239 # Type-checking happens elsewhere. This method is for selecting between -32240 # primitives. -32241 subx-type-category-match?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean -32242 # . prologue -32243 55/push-ebp -32244 89/<- %ebp 4/r32/esp -32245 # . save registers -32246 51/push-ecx -32247 # var cata/ecx: int = type-category(a) -32248 (type-category *(ebp+8)) # => eax -32249 89/<- %ecx 0/r32/eax -32250 # var catb/eax: int = type-category(b) -32251 (type-category *(ebp+0xc)) # => eax -32252 # return cata == catb -32253 39/compare %eax 1/r32/ecx -32254 0f 94/set-byte-if-= %al -32255 81 4/subop/and %eax 0xff/imm32 -32256 $subx-type-category-match?:end: -32257 # . restore registers -32258 59/pop-to-ecx -32259 # . epilogue -32260 89/<- %esp 5/r32/ebp -32261 5d/pop-to-ebp -32262 c3/return -32263 -32264 type-category: # a: (addr type-tree) -> result/eax: int -32265 # . prologue -32266 55/push-ebp -32267 89/<- %ebp 4/r32/esp -32268 # . save registers -32269 51/push-ecx -32270 # var lit?/ecx: boolean = is-literal-type?(a) -32271 (is-simple-mu-type? *(ebp+8) 0) # literal => eax -32272 89/<- %ecx 0/r32/eax -32273 # var float?/eax: int = is-float?(a) -32274 (is-simple-mu-type? *(ebp+8) 0xf) # => eax -32275 # set bits for lit? and float? -32276 c1/shift 4/subop/left %ecx 1/imm8 -32277 09/or %eax 1/r32/ecx -32278 $type-category:end: -32279 # . restore registers -32280 59/pop-to-ecx -32281 # . epilogue -32282 89/<- %esp 5/r32/ebp -32283 5d/pop-to-ebp -32284 c3/return -32285 -32286 is-simple-mu-type?: # a: (addr type-tree), n: type-id -> result/eax: boolean -32287 # . prologue -32288 55/push-ebp -32289 89/<- %ebp 4/r32/esp -32290 # . save registers -32291 51/push-ecx -32292 # ecx = n -32293 8b/-> *(ebp+0xc) 1/r32/ecx -32294 # return (a->value == n) -32295 8b/-> *(ebp+8) 0/r32/eax -32296 39/compare *(eax+4) 1/r32/ecx # Type-tree-value -32297 0f 94/set-byte-if-= %al -32298 81 4/subop/and %eax 0xff/imm32 -32299 $is-simple-mu-type?:end: -32300 # . restore registers -32301 59/pop-to-ecx -32302 # . epilogue -32303 89/<- %esp 5/r32/ebp -32304 5d/pop-to-ebp -32305 c3/return +31298 # "increment" +31299 0x9/imm32/size +31300 0x69/i 0x6e/n 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t +31301 _string-loop: # (payload array byte) +31302 0x11/imm32/alloc-id:fake:payload +31303 # "loop" +31304 0x4/imm32/size +31305 0x6c/l 0x6f/o 0x6f/o 0x70/p +31306 _string-loop-if-<: # (payload array byte) +31307 0x11/imm32/alloc-id:fake:payload +31308 # "loop-if-<" +31309 0x9/imm32/size +31310 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< +31311 _string-loop-if-<=: # (payload array byte) +31312 0x11/imm32/alloc-id:fake:payload +31313 # "loop-if-<=" +31314 0xa/imm32/size +31315 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3c/< 0x3d/= +31316 _string-loop-if-=: # (payload array byte) +31317 0x11/imm32/alloc-id:fake:payload +31318 # "loop-if-=" +31319 0x9/imm32/size +31320 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3d/= +31321 _string-loop-if->: # (payload array byte) +31322 0x11/imm32/alloc-id:fake:payload +31323 # "loop-if->" +31324 0x9/imm32/size +31325 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> +31326 _string-loop-if->=: # (payload array byte) +31327 0x11/imm32/alloc-id:fake:payload +31328 # "loop-if->=" +31329 0xa/imm32/size +31330 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x3e/> 0x3d/= +31331 _string-loop-if-!=: # (payload array byte) +31332 0x11/imm32/alloc-id:fake:payload +31333 # "loop-if-!=" +31334 0xa/imm32/size +31335 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x21/! 0x3d/= +31336 _string-loop-if-addr<: # (payload array byte) +31337 0x11/imm32/alloc-id:fake:payload +31338 # "loop-if-addr<" +31339 0xd/imm32/size +31340 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/< +31341 _string-loop-if-addr<=: # (payload array byte) +31342 0x11/imm32/alloc-id:fake:payload +31343 # "loop-if-addr<=" +31344 0xe/imm32/size +31345 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/= +31346 _string-loop-if-addr>: # (payload array byte) +31347 0x11/imm32/alloc-id:fake:payload +31348 # "loop-if-addr>" +31349 0xd/imm32/size +31350 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/> +31351 _string-loop-if-addr>=: # (payload array byte) +31352 0x11/imm32/alloc-id:fake:payload +31353 # "loop-if-addr>=" +31354 0xe/imm32/size +31355 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/= +31356 _string-loop-if-float<: # (payload array byte) +31357 0x11/imm32/alloc-id:fake:payload +31358 # "loop-if-float<" +31359 0xe/imm32/size +31360 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< +31361 _string-loop-if-float<=: # (payload array byte) +31362 0x11/imm32/alloc-id:fake:payload +31363 # "loop-if-float<=" +31364 0xf/imm32/size +31365 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3c/< 0x3d/= +31366 _string-loop-if-float>: # (payload array byte) +31367 0x11/imm32/alloc-id:fake:payload +31368 # "loop-if-float>" +31369 0xe/imm32/size +31370 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> +31371 _string-loop-if-float>=: # (payload array byte) +31372 0x11/imm32/alloc-id:fake:payload +31373 # "loop-if-float>=" +31374 0xf/imm32/size +31375 0x6c/l 0x6f/o 0x6f/o 0x70/p 0x2d/dash 0x69/i 0x66/f 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t 0x3e/> 0x3d/= +31376 _string-multiply: # (payload array byte) +31377 0x11/imm32/alloc-id:fake:payload +31378 # "multiply" +31379 0x8/imm32/size +31380 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y +31381 _string-convert: # (payload array byte) +31382 0x11/imm32/alloc-id:fake:payload +31383 # "convert" +31384 0x7/imm32/size +31385 0x63/c 0x6f/o 0x6e/n 0x76/v 0x65/e 0x72/r 0x74/t +31386 _string-truncate: # (payload array byte) +31387 0x11/imm32/alloc-id:fake:payload +31388 # "truncate" +31389 0x8/imm32/size +31390 0x74/t 0x72/r 0x75/u 0x6e/n 0x63/c 0x61/a 0x74/t 0x65/e +31391 _string-reinterpret: # (payload array byte) +31392 0x11/imm32/alloc-id:fake:payload +31393 # "reinterpret" +31394 0xb/imm32/size +31395 0x72/r 0x65/e 0x69/i 0x6e/n 0x74/t 0x65/e 0x72/r 0x70/p 0x72/r 0x65/e 0x74/t +31396 _string-divide: +31397 0x11/imm32/alloc-id:fake:payload +31398 # "divide" +31399 0x6/imm32/size +31400 0x64/d 0x69/i 0x76/v 0x69/i 0x64/d 0x65/e +31401 _string-max: +31402 0x11/imm32/alloc-id:fake:payload +31403 # "max" +31404 0x3/imm32/size +31405 0x6d/m 0x61/a 0x78/x +31406 _string-min: +31407 0x11/imm32/alloc-id:fake:payload +31408 # "min" +31409 0x3/imm32/size +31410 0x6d/m 0x69/i 0x6e/n +31411 _string-reciprocal: +31412 0x11/imm32/alloc-id:fake:payload +31413 # "reciprocal" +31414 0xa/imm32/size +31415 0x72/r 0x65/e 0x63/c 0x69/i 0x70/p 0x72/r 0x6f/o 0x63/c 0x61/a 0x6c/l +31416 _string-square-root: +31417 0x11/imm32/alloc-id:fake:payload +31418 # "square-root" +31419 0xb/imm32/size +31420 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/- 0x72/r 0x6f/o 0x6f/o 0x74/t +31421 _string-inverse-square-root: +31422 0x11/imm32/alloc-id:fake:payload +31423 # "inverse-square-root" +31424 0x13/imm32/size +31425 0x69/i 0x6e/n 0x76/v 0x65/e 0x72/r 0x73/s 0x65/e 0x2d/- 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/- 0x72/r 0x6f/o 0x6f/o 0x74/t +31426 _string-negate: # (payload array byte) +31427 0x11/imm32/alloc-id:fake:payload +31428 # "negate" +31429 0x6/imm32/size +31430 0x6e/n 0x65/e 0x67/g 0x61/a 0x74/t 0x65/e +31431 _string-or: # (payload array byte) +31432 0x11/imm32/alloc-id:fake:payload +31433 # "or" +31434 0x2/imm32/size +31435 0x6f/o 0x72/r +31436 _string-or-with: # (payload array byte) +31437 0x11/imm32/alloc-id:fake:payload +31438 # "or-with" +31439 0x7/imm32/size +31440 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +31441 _string-subtract: # (payload array byte) +31442 0x11/imm32/alloc-id:fake:payload +31443 # "subtract" +31444 0x8/imm32/size +31445 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t +31446 _string-subtract-from: # (payload array byte) +31447 0x11/imm32/alloc-id:fake:payload +31448 # "subtract-from" +31449 0xd/imm32/size +31450 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 +31451 _string-xor: # (payload array byte) +31452 0x11/imm32/alloc-id:fake:payload +31453 # "xor" +31454 0x3/imm32/size +31455 0x78/x 0x6f/o 0x72/r +31456 _string-xor-with: # (payload array byte) +31457 0x11/imm32/alloc-id:fake:payload +31458 # "xor-with" +31459 0x8/imm32/size +31460 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +31461 _string-shift-left: # (payload array byte) +31462 0x11/imm32/alloc-id:fake:payload +31463 # "shift-left" +31464 0xa/imm32/size +31465 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x6c/l 0x65/e 0x66/f 0x74/t +31466 _string-shift-right: # (payload array byte) +31467 0x11/imm32/alloc-id:fake:payload +31468 # "shift-right" +31469 0xb/imm32/size +31470 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t +31471 _string-shift-right-signed: # (payload array byte) +31472 0x11/imm32/alloc-id:fake:payload +31473 # "shift-right-signed" +31474 0x12/imm32/size +31475 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x2d/dash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n 0x65/e 0x64/d +31476 +31477 # string literals for SubX instructions +31478 _string_01_add_to: # (payload array byte) +31479 0x11/imm32/alloc-id:fake:payload +31480 # "01/add-to" +31481 0x9/imm32/size +31482 0x30/0 0x31/1 0x2f/slash 0x61/a 0x64/d 0x64/d 0x2d/dash 0x74/t 0x6f/o +31483 _string_03_add: # (payload array byte) +31484 0x11/imm32/alloc-id:fake:payload +31485 # "03/add" +31486 0x6/imm32/size +31487 0x30/0 0x33/3 0x2f/slash 0x61/a 0x64/d 0x64/d +31488 _string_05_add_to_eax: # (payload array byte) +31489 0x11/imm32/alloc-id:fake:payload +31490 # "05/add-to-eax" +31491 0xd/imm32/size +31492 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 +31493 _string_09_or_with: # (payload array byte) +31494 0x11/imm32/alloc-id:fake:payload +31495 # "09/or-with" +31496 0xa/imm32/size +31497 0x30/0 0x39/9 0x2f/slash 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +31498 _string_0b_or: # (payload array byte) +31499 0x11/imm32/alloc-id:fake:payload +31500 # "0b/or" +31501 0x5/imm32/size +31502 0x30/0 0x62/b 0x2f/slash 0x6f/o 0x72/r +31503 _string_0d_or_with_eax: # (payload array byte) +31504 0x11/imm32/alloc-id:fake:payload +31505 # "0d/or-with-eax" +31506 0xe/imm32/size +31507 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 +31508 _string_0f_82_jump_label: # (payload array byte) +31509 0x11/imm32/alloc-id:fake:payload +31510 # "0f 82/jump-if-addr<" +31511 0x13/imm32/size +31512 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/< +31513 _string_0f_82_jump_break: # (payload array byte) +31514 0x11/imm32/alloc-id:fake:payload +31515 # "0f 82/jump-if-addr< break/disp32" +31516 0x20/imm32/size +31517 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 +31518 _string_0f_82_jump_loop: # (payload array byte) +31519 0x11/imm32/alloc-id:fake:payload +31520 # "0f 82/jump-if-addr< loop/disp32" +31521 0x1f/imm32/size +31522 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 +31523 _string_0f_83_jump_label: # (payload array byte) +31524 0x11/imm32/alloc-id:fake:payload +31525 # "0f 83/jump-if-addr>=" +31526 0x14/imm32/size +31527 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/= +31528 _string_0f_83_jump_break: # (payload array byte) +31529 0x11/imm32/alloc-id:fake:payload +31530 # "0f 83/jump-if-addr>= break/disp32" +31531 0x21/imm32/size +31532 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 +31533 _string_0f_83_jump_loop: # (payload array byte) +31534 0x11/imm32/alloc-id:fake:payload +31535 # "0f 83/jump-if-addr>= loop/disp32" +31536 0x20/imm32/size +31537 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 +31538 _string_0f_84_jump_label: # (payload array byte) +31539 0x11/imm32/alloc-id:fake:payload +31540 # "0f 84/jump-if-=" +31541 0xf/imm32/size +31542 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/= +31543 _string_0f_84_jump_break: # (payload array byte) +31544 0x11/imm32/alloc-id:fake:payload +31545 # "0f 84/jump-if-= break/disp32" +31546 0x1c/imm32/size +31547 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 +31548 _string_0f_84_jump_loop: # (payload array byte) +31549 0x11/imm32/alloc-id:fake:payload +31550 # "0f 84/jump-if-= loop/disp32" +31551 0x1b/imm32/size +31552 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 +31553 _string_0f_85_jump_label: # (payload array byte) +31554 0x11/imm32/alloc-id:fake:payload +31555 # "0f 85/jump-if-!=" +31556 0x10/imm32/size +31557 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/= +31558 _string_0f_85_jump_break: # (payload array byte) +31559 0x11/imm32/alloc-id:fake:payload +31560 # "0f 85/jump-if-!= break/disp32" +31561 0x1d/imm32/size +31562 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 +31563 _string_0f_85_jump_loop: # (payload array byte) +31564 0x11/imm32/alloc-id:fake:payload +31565 # "0f 85/jump-if-!= loop/disp32" +31566 0x1c/imm32/size +31567 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 +31568 _string_0f_86_jump_label: # (payload array byte) +31569 0x11/imm32/alloc-id:fake:payload +31570 # "0f 86/jump-if-addr<=" +31571 0x14/imm32/size +31572 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/= +31573 _string_0f_86_jump_break: # (payload array byte) +31574 0x11/imm32/alloc-id:fake:payload +31575 # "0f 86/jump-if-addr<= break/disp32" +31576 0x21/imm32/size +31577 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 +31578 _string_0f_86_jump_loop: # (payload array byte) +31579 0x11/imm32/alloc-id:fake:payload +31580 # "0f 86/jump-if-addr<= loop/disp32" +31581 0x20/imm32/size +31582 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 +31583 _string_0f_87_jump_label: # (payload array byte) +31584 0x11/imm32/alloc-id:fake:payload +31585 # "0f 87/jump-if-addr>" +31586 0x13/imm32/size +31587 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/> +31588 _string_0f_87_jump_break: # (payload array byte) +31589 0x11/imm32/alloc-id:fake:payload +31590 # "0f 87/jump-if-addr> break/disp32" +31591 0x20/imm32/size +31592 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 +31593 _string_0f_87_jump_loop: # (payload array byte) +31594 0x11/imm32/alloc-id:fake:payload +31595 # "0f 87/jump-if-addr> loop/disp32" +31596 0x1f/imm32/size +31597 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 +31598 _string_0f_8c_jump_label: # (payload array byte) +31599 0x11/imm32/alloc-id:fake:payload +31600 # "0f 8c/jump-if-<" +31601 0xf/imm32/size +31602 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/< +31603 _string_0f_8c_jump_break: # (payload array byte) +31604 0x11/imm32/alloc-id:fake:payload +31605 # "0f 8c/jump-if-< break/disp32" +31606 0x1c/imm32/size +31607 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 +31608 _string_0f_8c_jump_loop: # (payload array byte) +31609 0x11/imm32/alloc-id:fake:payload +31610 # "0f 8c/jump-if-< loop/disp32" +31611 0x1b/imm32/size +31612 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 +31613 _string_0f_8d_jump_label: # (payload array byte) +31614 0x11/imm32/alloc-id:fake:payload +31615 # "0f 8d/jump-if->=" +31616 0x10/imm32/size +31617 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/= +31618 _string_0f_8d_jump_break: # (payload array byte) +31619 0x11/imm32/alloc-id:fake:payload +31620 # "0f 8d/jump-if->= break/disp32" +31621 0x1d/imm32/size +31622 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 +31623 _string_0f_8d_jump_loop: # (payload array byte) +31624 0x11/imm32/alloc-id:fake:payload +31625 # "0f 8d/jump-if->= loop/disp32" +31626 0x1c/imm32/size +31627 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 +31628 _string_0f_8e_jump_label: # (payload array byte) +31629 0x11/imm32/alloc-id:fake:payload +31630 # "0f 8e/jump-if-<=" +31631 0x10/imm32/size +31632 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/= +31633 _string_0f_8e_jump_break: # (payload array byte) +31634 0x11/imm32/alloc-id:fake:payload +31635 # "0f 8e/jump-if-<= break/disp32" +31636 0x1d/imm32/size +31637 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 +31638 _string_0f_8e_jump_loop: # (payload array byte) +31639 0x11/imm32/alloc-id:fake:payload +31640 # "0f 8e/jump-if-<= loop/disp32" +31641 0x1c/imm32/size +31642 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 +31643 _string_0f_8f_jump_label: # (payload array byte) +31644 0x11/imm32/alloc-id:fake:payload +31645 # "0f 8f/jump-if->" +31646 0xf/imm32/size +31647 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/> +31648 _string_0f_8f_jump_break: # (payload array byte) +31649 0x11/imm32/alloc-id:fake:payload +31650 # "0f 8f/jump-if-> break/disp32" +31651 0x1c/imm32/size +31652 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 +31653 _string_0f_8f_jump_loop: # (payload array byte) +31654 0x11/imm32/alloc-id:fake:payload +31655 # "0f 8f/jump-if-> loop/disp32" +31656 0x1b/imm32/size +31657 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 +31658 _string_0f_af_multiply: # (payload array byte) +31659 0x11/imm32/alloc-id:fake:payload +31660 # "0f af/multiply" +31661 0xe/imm32/size +31662 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 +31663 _string_f3_0f_2a_convert_to_float: +31664 0x11/imm32/alloc-id:fake:payload +31665 # "f3 0f 2a/convert-to-float" +31666 0x19/imm32/size +31667 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x32/2 0x61/a 0x2f/slash 0x63/c 0x6f/o 0x6e/n 0x76/v 0x65/e 0x72/r 0x74/t 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x66/f 0x6c/l 0x6f/o 0x61/a 0x74/t +31668 _string_f3_0f_2d_convert_to_int: +31669 0x11/imm32/alloc-id:fake:payload +31670 # "f3 0f 2d/convert-to-int" +31671 0x17/imm32/size +31672 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x32/2 0x64/d 0x2f/slash 0x63/c 0x6f/o 0x6e/n 0x76/v 0x65/e 0x72/r 0x74/t 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x69/i 0x6e/n 0x74/t +31673 _string_f3_0f_2c_truncate_to_int: +31674 0x11/imm32/alloc-id:fake:payload +31675 # "f3 0f 2c/truncate-to-int" +31676 0x18/imm32/size +31677 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x32/2 0x63/c 0x2f/slash 0x74/t 0x72/r 0x75/u 0x6e/n 0x63/c 0x61/a 0x74/t 0x65/e 0x2d/dash 0x74/t 0x6f/o 0x2d/dash 0x69/i 0x6e/n 0x74/t +31678 _string_f3_0f_58_add: +31679 0x11/imm32/alloc-id:fake:payload +31680 # "f3 0f 58/add" +31681 0xc/imm32/size +31682 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x38/8 0x2f/slash 0x61/a 0x64/d 0x64/d +31683 _string_f3_0f_5c_subtract: +31684 0x11/imm32/alloc-id:fake:payload +31685 # "f3 0f 5c/subtract" +31686 0x11/imm32/size +31687 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x63/c 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t +31688 _string_f3_0f_59_multiply: +31689 0x11/imm32/alloc-id:fake:payload +31690 # "f3 0f 59/multiply" +31691 0x11/imm32/size +31692 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x39/9 0x2f/slash 0x6d/m 0x75/u 0x6c/l 0x74/t 0x69/i 0x70/p 0x6c/l 0x79/y +31693 _string_f3_0f_5e_divide: +31694 0x11/imm32/alloc-id:fake:payload +31695 # "f3 0f 5e/divide" +31696 0xf/imm32/size +31697 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x65/e 0x2f/slash 0x64/d 0x69/i 0x76/v 0x69/i 0x64/d 0x65/e +31698 _string_f3_0f_53_reciprocal: +31699 0x11/imm32/alloc-id:fake:payload +31700 # "f3 0f 53/reciprocal" +31701 0x13/imm32/size +31702 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x33/3 0x2f/slash 0x72/r 0x65/e 0x63/c 0x69/i 0x70/p 0x72/r 0x6f/o 0x63/c 0x61/a 0x6c/l +31703 _string_f3_0f_51_square_root: +31704 0x11/imm32/alloc-id:fake:payload +31705 # "f3 0f 51/square-root" +31706 0x14/imm32/size +31707 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x31/1 0x2f/slash 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/dash 0x72/r 0x6f/o 0x6f/o 0x74/t +31708 _string_f3_0f_52_inverse_square_root: +31709 0x11/imm32/alloc-id:fake:payload +31710 # "f3 0f 52/inverse-square-root" +31711 0x1c/imm32/size +31712 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x32/2 0x2f/slash 0x69/i 0x6e/n 0x76/v 0x65/e 0x72/r 0x73/s 0x65/e 0x2d/dash 0x73/s 0x71/q 0x75/u 0x61/a 0x72/r 0x65/e 0x2d/dash 0x72/r 0x6f/o 0x6f/o 0x74/t +31713 _string_f3_0f_5d_min: +31714 0x11/imm32/alloc-id:fake:payload +31715 # "f3 0f 5d/min" +31716 0xc/imm32/size +31717 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x64/d 0x2f/slash 0x6d/m 0x69/i 0x6e/n +31718 _string_f3_0f_5f_max: +31719 0x11/imm32/alloc-id:fake:payload +31720 # "f3 0f 5f/max" +31721 0xc/imm32/size +31722 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x35/5 0x66/f 0x2f/slash 0x6d/m 0x61/a 0x78/x +31723 _string_f3_0f_10_copy: +31724 0x11/imm32/alloc-id:fake:payload +31725 # "f3 0f 10/copy" +31726 0xd/imm32/size +31727 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x31/1 0x30/0 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y +31728 _string_f3_0f_11_copy: +31729 0x11/imm32/alloc-id:fake:payload +31730 # "f3 0f 11/copy" +31731 0xd/imm32/size +31732 0x66/f 0x33/3 0x20/space 0x30/0 0x66/f 0x20/space 0x31/1 0x31/1 0x2f/slash 0x63/c 0x6f/o 0x70/p 0x79/y +31733 _string_0f_2f_compare: +31734 0x11/imm32/alloc-id:fake:payload +31735 # "0f 2f/compare" +31736 0xd/imm32/size +31737 0x30/0 0x66/f 0x20/space 0x32/2 0x66/f 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e +31738 _string_21_and_with: # (payload array byte) +31739 0x11/imm32/alloc-id:fake:payload +31740 # "21/and-with" +31741 0xb/imm32/size +31742 0x32/2 0x31/1 0x2f/slash 0x61/a 0x6e/n 0x64/d 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +31743 _string_23_and: # (payload array byte) +31744 0x11/imm32/alloc-id:fake:payload +31745 # "23/and" +31746 0x6/imm32/size +31747 0x32/2 0x33/3 0x2f/slash 0x61/a 0x6e/n 0x64/d +31748 _string_25_and_with_eax: # (payload array byte) +31749 0x11/imm32/alloc-id:fake:payload +31750 # "25/and-with-eax" +31751 0xf/imm32/size +31752 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 +31753 _string_29_subtract_from: # (payload array byte) +31754 0x11/imm32/alloc-id:fake:payload +31755 # "29/subtract-from" +31756 0x10/imm32/size +31757 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 +31758 _string_2b_subtract: # (payload array byte) +31759 0x11/imm32/alloc-id:fake:payload +31760 # "2b/subtract" +31761 0xb/imm32/size +31762 0x32/2 0x62/b 0x2f/slash 0x73/s 0x75/u 0x62/b 0x74/t 0x72/r 0x61/a 0x63/c 0x74/t +31763 _string_2d_subtract_from_eax: # (payload array byte) +31764 0x11/imm32/alloc-id:fake:payload +31765 # "2d/subtract-from-eax" +31766 0x14/imm32/size +31767 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 +31768 _string_31_xor_with: # (payload array byte) +31769 0x11/imm32/alloc-id:fake:payload +31770 # "31/xor-with" +31771 0xb/imm32/size +31772 0x33/3 0x31/1 0x2f/slash 0x78/x 0x6f/o 0x72/r 0x2d/dash 0x77/w 0x69/i 0x74/t 0x68/h +31773 _string_33_xor: # (payload array byte) +31774 0x11/imm32/alloc-id:fake:payload +31775 # "33/xor" +31776 0x6/imm32/size +31777 0x33/3 0x33/3 0x2f/slash 0x78/x 0x6f/o 0x72/r +31778 _string_35_xor_with_eax: # (payload array byte) +31779 0x11/imm32/alloc-id:fake:payload +31780 # "35/xor-with-eax" +31781 0xf/imm32/size +31782 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 +31783 _string_39_compare->: # (payload array byte) +31784 0x11/imm32/alloc-id:fake:payload +31785 # "39/compare->" +31786 0xc/imm32/size +31787 0x33/3 0x39/9 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x2d/dash 0x3e/> +31788 _string_3b_compare<-: # (payload array byte) +31789 0x11/imm32/alloc-id:fake:payload +31790 # "3b/compare<-" +31791 0xc/imm32/size +31792 0x33/3 0x62/b 0x2f/slash 0x63/c 0x6f/o 0x6d/m 0x70/p 0x61/a 0x72/r 0x65/e 0x3c/< 0x2d/dash +31793 _string_3d_compare_eax_with: # (payload array byte) +31794 0x11/imm32/alloc-id:fake:payload +31795 # "3d/compare-eax-with" +31796 0x13/imm32/size +31797 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 +31798 _string_40_increment_eax: # (payload array byte) +31799 0x11/imm32/alloc-id:fake:payload +31800 # "40/increment-eax" +31801 0x10/imm32/size +31802 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 +31803 _string_41_increment_ecx: # (payload array byte) +31804 0x11/imm32/alloc-id:fake:payload +31805 # "41/increment-ecx" +31806 0x10/imm32/size +31807 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 +31808 _string_42_increment_edx: # (payload array byte) +31809 0x11/imm32/alloc-id:fake:payload +31810 # "42/increment-edx" +31811 0x10/imm32/size +31812 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 +31813 _string_43_increment_ebx: # (payload array byte) +31814 0x11/imm32/alloc-id:fake:payload +31815 # "43/increment-ebx" +31816 0x10/imm32/size +31817 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 +31818 _string_46_increment_esi: # (payload array byte) +31819 0x11/imm32/alloc-id:fake:payload +31820 # "46/increment-esi" +31821 0x10/imm32/size +31822 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 +31823 _string_47_increment_edi: # (payload array byte) +31824 0x11/imm32/alloc-id:fake:payload +31825 # "47/increment-edi" +31826 0x10/imm32/size +31827 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 +31828 _string_48_decrement_eax: # (payload array byte) +31829 0x11/imm32/alloc-id:fake:payload +31830 # "48/decrement-eax" +31831 0x10/imm32/size +31832 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 +31833 _string_49_decrement_ecx: # (payload array byte) +31834 0x11/imm32/alloc-id:fake:payload +31835 # "49/decrement-ecx" +31836 0x10/imm32/size +31837 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 +31838 _string_4a_decrement_edx: # (payload array byte) +31839 0x11/imm32/alloc-id:fake:payload +31840 # "4a/decrement-edx" +31841 0x10/imm32/size +31842 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 +31843 _string_4b_decrement_ebx: # (payload array byte) +31844 0x11/imm32/alloc-id:fake:payload +31845 # "4b/decrement-ebx" +31846 0x10/imm32/size +31847 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 +31848 _string_4e_decrement_esi: # (payload array byte) +31849 0x11/imm32/alloc-id:fake:payload +31850 # "4e/decrement-esi" +31851 0x10/imm32/size +31852 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 +31853 _string_4f_decrement_edi: # (payload array byte) +31854 0x11/imm32/alloc-id:fake:payload +31855 # "4f/decrement-edi" +31856 0x10/imm32/size +31857 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 +31858 _string_81_subop_add: # (payload array byte) +31859 0x11/imm32/alloc-id:fake:payload +31860 # "81 0/subop/add" +31861 0xe/imm32/size +31862 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 +31863 _string_81_subop_or: # (payload array byte) +31864 0x11/imm32/alloc-id:fake:payload +31865 # "81 1/subop/or" +31866 0xd/imm32/size +31867 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 +31868 _string_81_subop_and: # (payload array byte) +31869 0x11/imm32/alloc-id:fake:payload +31870 # "81 4/subop/and" +31871 0xe/imm32/size +31872 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 +31873 _string_81_subop_subtract: # (payload array byte) +31874 0x11/imm32/alloc-id:fake:payload +31875 # "81 5/subop/subtract" +31876 0x13/imm32/size +31877 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 +31878 _string_81_subop_xor: # (payload array byte) +31879 0x11/imm32/alloc-id:fake:payload +31880 # "81 6/subop/xor" +31881 0xe/imm32/size +31882 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 +31883 _string_81_subop_compare: # (payload array byte) +31884 0x11/imm32/alloc-id:fake:payload +31885 # "81 7/subop/compare" +31886 0x12/imm32/size +31887 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 +31888 _string_89_<-: # (payload array byte) +31889 0x11/imm32/alloc-id:fake:payload +31890 # "89/<-" +31891 0x5/imm32/size +31892 0x38/8 0x39/9 0x2f/slash 0x3c/< 0x2d/dash +31893 _string_8b_->: # (payload array byte) +31894 0x11/imm32/alloc-id:fake:payload +31895 # "8b/->" +31896 0x5/imm32/size +31897 0x38/8 0x62/b 0x2f/slash 0x2d/dash 0x3e/> +31898 _string_8a_copy_byte: +31899 0x11/imm32/alloc-id:fake:payload +31900 # "8a/byte->" +31901 0x9/imm32/size +31902 0x38/8 0x61/a 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x2d/- 0x3e/> +31903 _string_88_copy_byte: +31904 0x11/imm32/alloc-id:fake:payload +31905 # "88/byte<-" +31906 0x9/imm32/size +31907 0x38/8 0x38/8 0x2f// 0x62/b 0x79/y 0x74/t 0x65/e 0x3c/< 0x2d/- +31908 _string_8d_copy_address: # (payload array byte) +31909 0x11/imm32/alloc-id:fake:payload +31910 # "8d/copy-address" +31911 0xf/imm32/size +31912 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 +31913 _string_b8_copy_to_eax: # (payload array byte) +31914 0x11/imm32/alloc-id:fake:payload +31915 # "b8/copy-to-eax" +31916 0xe/imm32/size +31917 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 +31918 _string_b9_copy_to_ecx: # (payload array byte) +31919 0x11/imm32/alloc-id:fake:payload +31920 # "b9/copy-to-ecx" +31921 0xe/imm32/size +31922 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 +31923 _string_ba_copy_to_edx: # (payload array byte) +31924 0x11/imm32/alloc-id:fake:payload +31925 # "ba/copy-to-edx" +31926 0xe/imm32/size +31927 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 +31928 _string_bb_copy_to_ebx: # (payload array byte) +31929 0x11/imm32/alloc-id:fake:payload +31930 # "bb/copy-to-ebx" +31931 0xe/imm32/size +31932 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 +31933 _string_be_copy_to_esi: # (payload array byte) +31934 0x11/imm32/alloc-id:fake:payload +31935 # "be/copy-to-esi" +31936 0xe/imm32/size +31937 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 +31938 _string_bf_copy_to_edi: # (payload array byte) +31939 0x11/imm32/alloc-id:fake:payload +31940 # "bf/copy-to-edi" +31941 0xe/imm32/size +31942 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 +31943 _string_c7_subop_copy: # (payload array byte) +31944 0x11/imm32/alloc-id:fake:payload +31945 # "c7 0/subop/copy" +31946 0xf/imm32/size +31947 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 +31948 _string_e9_jump_label: # (payload array byte) +31949 0x11/imm32/alloc-id:fake:payload +31950 # "e9/jump" +31951 0x7/imm32/size +31952 0x65/e 0x39/9 0x2f/slash 0x6a/j 0x75/u 0x6d/m 0x70/p +31953 _string_e9_jump_break: # (payload array byte) +31954 0x11/imm32/alloc-id:fake:payload +31955 # "e9/jump break/disp32" +31956 0x14/imm32/size +31957 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 +31958 _string_e9_jump_loop: # (payload array byte) +31959 0x11/imm32/alloc-id:fake:payload +31960 # "e9/jump loop/disp32" +31961 0x13/imm32/size +31962 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 +31963 _string_f7_subop_negate: +31964 0x11/imm32/alloc-id:fake:payload +31965 # "f7 3/subop/negate" +31966 0x11/imm32/size +31967 0x66/f 0x37/7 0x20/space 0x33/3 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6e/n 0x65/e 0x67/g 0x61/a 0x74/t 0x65/e +31968 _string_ff_subop_increment: # (payload array byte) +31969 0x11/imm32/alloc-id:fake:payload +31970 # "ff 0/subop/increment" +31971 0x14/imm32/size +31972 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 +31973 _string_ff_subop_decrement: # (payload array byte) +31974 0x11/imm32/alloc-id:fake:payload +31975 # "ff 1/subop/decrement" +31976 0x14/imm32/size +31977 0x66/f 0x66/f 0x20/space 0x31/1 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x64/d 0x65/e 0x63/c 0x72/r 0x65/e 0x6d/m 0x65/e 0x6e/n 0x74/t +31978 _string_c1_subop_shift_left: # (payload array byte) +31979 0x11/imm32/alloc-id:fake:payload +31980 # "c1/shift 4/subop/left" +31981 0x15/imm32/size +31982 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x34/4 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x6c/l 0x65/e 0x66/f 0x74/t +31983 _string_c1_subop_shift_right_padding_zeroes: # (payload array byte) +31984 0x11/imm32/alloc-id:fake:payload +31985 # "c1/shift 5/subop/right-padding-zeroes" +31986 0x25/imm32/size +31987 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x35/5 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x61/a 0x64/d 0x64/d 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x7a/z 0x65/e 0x72/r 0x6f/o 0x65/e 0x73/s +31988 _string_c1_subop_shift_right_preserving_sign: # (payload array byte) +31989 0x11/imm32/alloc-id:fake:payload +31990 # "c1/shift 7/subop/right-preserving-sign" +31991 0x26/imm32/size +31992 0x63/c 0x31/1 0x2f/slash 0x73/s 0x68/h 0x69/i 0x66/f 0x74/t 0x20/space 0x37/7 0x2f/slash 0x73/s 0x75/u 0x62/b 0x6f/o 0x70/p 0x2f/slash 0x72/r 0x69/i 0x67/g 0x68/h 0x74/t 0x2d/dash 0x70/p 0x72/r 0x65/e 0x73/s 0x65/e 0x72/r 0x76/v 0x69/i 0x6e/n 0x67/g 0x2d/dash 0x73/s 0x69/i 0x67/g 0x6e/n +31993 +31994 Single-int-var-in-mem: # (payload list var) +31995 0x11/imm32/alloc-id:fake:payload +31996 0x11/imm32/alloc-id:fake +31997 Int-var-in-mem/imm32 +31998 0/imm32/next +31999 0/imm32/next +32000 +32001 Int-var-in-mem: # (payload var) +32002 0x11/imm32/alloc-id:fake:payload +32003 0/imm32/name +32004 0/imm32/name +32005 0x11/imm32/alloc-id:fake +32006 Type-int/imm32 +32007 1/imm32/some-block-depth +32008 1/imm32/some-stack-offset +32009 0/imm32/no-register +32010 0/imm32/no-register +32011 +32012 # Not really legal, but closest we can currently represent a dereference of an (addr byte) +32013 Single-byte-var-in-mem: # (payload list var) +32014 0x11/imm32/alloc-id:fake:payload +32015 0x11/imm32/alloc-id:fake +32016 Byte-var-in-mem/imm32 +32017 0/imm32/next +32018 0/imm32/next +32019 +32020 # Not really legal, but closest we can currently represent a dereference of an (addr byte) +32021 Byte-var-in-mem: # (payload var) +32022 0x11/imm32/alloc-id:fake:payload +32023 0/imm32/name +32024 0/imm32/name +32025 0x11/imm32/alloc-id:fake +32026 Type-byte/imm32 +32027 1/imm32/some-block-depth +32028 1/imm32/some-stack-offset +32029 0/imm32/no-register +32030 0/imm32/no-register +32031 +32032 Two-args-int-stack-int-reg: # (payload list var) +32033 0x11/imm32/alloc-id:fake:payload +32034 0x11/imm32/alloc-id:fake +32035 Int-var-in-mem/imm32 +32036 0x11/imm32/alloc-id:fake +32037 Single-int-var-in-some-register/imm32/next +32038 +32039 Two-int-args-in-regs: # (payload list var) +32040 0x11/imm32/alloc-id:fake:payload +32041 0x11/imm32/alloc-id:fake +32042 Int-var-in-some-register/imm32 +32043 0x11/imm32/alloc-id:fake +32044 Single-int-var-in-some-register/imm32/next +32045 +32046 # Not really legal, but closest we can currently represent a dereference of an (addr byte) +32047 Two-args-byte-stack-byte-reg: # (payload list var) +32048 0x11/imm32/alloc-id:fake:payload +32049 0x11/imm32/alloc-id:fake +32050 Byte-var-in-mem/imm32 +32051 0x11/imm32/alloc-id:fake +32052 Single-byte-var-in-some-register/imm32/next +32053 +32054 Two-args-int-reg-int-stack: # (payload list var) +32055 0x11/imm32/alloc-id:fake:payload +32056 0x11/imm32/alloc-id:fake +32057 Int-var-in-some-register/imm32 +32058 0x11/imm32/alloc-id:fake +32059 Single-int-var-in-mem/imm32/next +32060 +32061 Two-args-int-eax-int-literal: # (payload list var) +32062 0x11/imm32/alloc-id:fake:payload +32063 0x11/imm32/alloc-id:fake +32064 Int-var-in-eax/imm32 +32065 0x11/imm32/alloc-id:fake +32066 Single-lit-var/imm32/next +32067 +32068 Int-var-and-literal: # (payload list var) +32069 0x11/imm32/alloc-id:fake:payload +32070 0x11/imm32/alloc-id:fake +32071 Int-var-in-mem/imm32 +32072 0x11/imm32/alloc-id:fake +32073 Single-lit-var/imm32/next +32074 +32075 Int-var-in-register-and-literal: # (payload list var) +32076 0x11/imm32/alloc-id:fake:payload +32077 0x11/imm32/alloc-id:fake +32078 Int-var-in-some-register/imm32 +32079 0x11/imm32/alloc-id:fake +32080 Single-lit-var/imm32/next +32081 +32082 Two-float-args-in-regs: # (payload list var) +32083 0x11/imm32/alloc-id:fake:payload +32084 0x11/imm32/alloc-id:fake +32085 Float-var-in-some-register/imm32 +32086 0x11/imm32/alloc-id:fake +32087 Single-float-var-in-some-register/imm32/next +32088 +32089 Two-args-float-reg-float-stack: # (payload list var) +32090 0x11/imm32/alloc-id:fake:payload +32091 0x11/imm32/alloc-id:fake +32092 Float-var-in-some-register/imm32 +32093 0x11/imm32/alloc-id:fake +32094 Single-float-var-in-mem/imm32/next +32095 +32096 Two-args-float-stack-float-reg: # (payload list var) +32097 0x11/imm32/alloc-id:fake:payload +32098 0x11/imm32/alloc-id:fake +32099 Float-var-in-mem/imm32 +32100 0x11/imm32/alloc-id:fake +32101 Single-float-var-in-some-register/imm32/next +32102 +32103 Single-int-var-in-some-register: # (payload list var) +32104 0x11/imm32/alloc-id:fake:payload +32105 0x11/imm32/alloc-id:fake +32106 Int-var-in-some-register/imm32 +32107 0/imm32/next +32108 0/imm32/next +32109 +32110 Single-addr-var-in-some-register: # (payload list var) +32111 0x11/imm32/alloc-id:fake:payload +32112 0x11/imm32/alloc-id:fake +32113 Addr-var-in-some-register/imm32 +32114 0/imm32/next +32115 0/imm32/next +32116 +32117 Single-byte-var-in-some-register: # (payload list var) +32118 0x11/imm32/alloc-id:fake:payload +32119 0x11/imm32/alloc-id:fake +32120 Byte-var-in-some-register/imm32 +32121 0/imm32/next +32122 0/imm32/next +32123 +32124 Int-var-in-some-register: # (payload var) +32125 0x11/imm32/alloc-id:fake:payload +32126 0/imm32/name +32127 0/imm32/name +32128 0x11/imm32/alloc-id:fake +32129 Type-int/imm32 +32130 1/imm32/some-block-depth +32131 0/imm32/no-stack-offset +32132 0x11/imm32/alloc-id:fake +32133 Any-register/imm32 +32134 +32135 Any-register: # (payload array byte) +32136 0x11/imm32/alloc-id:fake:payload +32137 1/imm32/size +32138 # data +32139 2a/asterisk +32140 +32141 Addr-var-in-some-register: # (payload var) +32142 0x11/imm32/alloc-id:fake:payload +32143 0/imm32/name +32144 0/imm32/name +32145 0x11/imm32/alloc-id:fake +32146 Type-addr/imm32 +32147 1/imm32/some-block-depth +32148 0/imm32/no-stack-offset +32149 0x11/imm32/alloc-id:fake +32150 Any-register/imm32 +32151 +32152 Byte-var-in-some-register: # (payload var) +32153 0x11/imm32/alloc-id:fake:payload +32154 0/imm32/name +32155 0/imm32/name +32156 0x11/imm32/alloc-id:fake +32157 Type-byte/imm32 +32158 1/imm32/some-block-depth +32159 0/imm32/no-stack-offset +32160 0x11/imm32/alloc-id:fake +32161 Any-register/imm32 +32162 +32163 Single-int-var-in-eax: # (payload list var) +32164 0x11/imm32/alloc-id:fake:payload +32165 0x11/imm32/alloc-id:fake +32166 Int-var-in-eax/imm32 +32167 0/imm32/next +32168 0/imm32/next +32169 +32170 Int-var-in-eax: +32171 0x11/imm32/alloc-id:fake:payload +32172 0/imm32/name +32173 0/imm32/name +32174 0x11/imm32/alloc-id:fake +32175 Type-int/imm32 +32176 1/imm32/some-block-depth +32177 0/imm32/no-stack-offset +32178 0x11/imm32/alloc-id:fake +32179 $Mu-register-eax/imm32 # can't use Register-eax only to keep our buggy tools/treeshake.cc happy (TODO) +32180 +32181 Single-int-var-in-ecx: # (payload list var) +32182 0x11/imm32/alloc-id:fake:payload +32183 0x11/imm32/alloc-id:fake +32184 Int-var-in-ecx/imm32 +32185 0/imm32/next +32186 0/imm32/next +32187 +32188 Int-var-in-ecx: +32189 0x11/imm32/alloc-id:fake:payload +32190 0/imm32/name +32191 0/imm32/name +32192 0x11/imm32/alloc-id:fake +32193 Type-int/imm32 +32194 1/imm32/some-block-depth +32195 0/imm32/no-stack-offset +32196 0x11/imm32/alloc-id:fake +32197 $Register-ecx/imm32/register +32198 +32199 Single-int-var-in-edx: # (payload list var) +32200 0x11/imm32/alloc-id:fake:payload +32201 0x11/imm32/alloc-id:fake +32202 Int-var-in-edx/imm32 +32203 0/imm32/next +32204 0/imm32/next +32205 +32206 Int-var-in-edx: # (payload list var) +32207 0x11/imm32/alloc-id:fake:payload +32208 0/imm32/name +32209 0/imm32/name +32210 0x11/imm32/alloc-id:fake +32211 Type-int/imm32 +32212 1/imm32/some-block-depth +32213 0/imm32/no-stack-offset +32214 0x11/imm32/alloc-id:fake +32215 $Register-edx/imm32/register +32216 +32217 Single-int-var-in-ebx: # (payload list var) +32218 0x11/imm32/alloc-id:fake:payload +32219 0x11/imm32/alloc-id:fake +32220 Int-var-in-ebx/imm32 +32221 0/imm32/next +32222 0/imm32/next +32223 +32224 Int-var-in-ebx: # (payload list var) +32225 0x11/imm32/alloc-id:fake:payload +32226 0/imm32/name +32227 0/imm32/name +32228 0x11/imm32/alloc-id:fake +32229 Type-int/imm32 +32230 1/imm32/some-block-depth +32231 0/imm32/no-stack-offset +32232 0x11/imm32/alloc-id:fake +32233 $Register-ebx/imm32/register +32234 +32235 Single-int-var-in-esi: # (payload list var) +32236 0x11/imm32/alloc-id:fake:payload +32237 0x11/imm32/alloc-id:fake +32238 Int-var-in-esi/imm32 +32239 0/imm32/next +32240 0/imm32/next +32241 +32242 Int-var-in-esi: # (payload list var) +32243 0x11/imm32/alloc-id:fake:payload +32244 0/imm32/name +32245 0/imm32/name +32246 0x11/imm32/alloc-id:fake +32247 Type-int/imm32 +32248 1/imm32/some-block-depth +32249 0/imm32/no-stack-offset +32250 0x11/imm32/alloc-id:fake +32251 $Register-esi/imm32/register +32252 +32253 Single-int-var-in-edi: # (payload list var) +32254 0x11/imm32/alloc-id:fake:payload +32255 0x11/imm32/alloc-id:fake +32256 Int-var-in-edi/imm32 +32257 0/imm32/next +32258 0/imm32/next +32259 +32260 Int-var-in-edi: # (payload list var) +32261 0x11/imm32/alloc-id:fake:payload +32262 0/imm32/name +32263 0/imm32/name +32264 0x11/imm32/alloc-id:fake +32265 Type-int/imm32 +32266 1/imm32/some-block-depth +32267 0/imm32/no-stack-offset +32268 0x11/imm32/alloc-id:fake +32269 $Register-edi/imm32/register +32270 +32271 Single-lit-var: # (payload list var) +32272 0x11/imm32/alloc-id:fake:payload +32273 0x11/imm32/alloc-id:fake +32274 Lit-var/imm32 +32275 0/imm32/next +32276 0/imm32/next +32277 +32278 Lit-var: # (payload var) +32279 0x11/imm32/alloc-id:fake:payload +32280 0/imm32/name +32281 0/imm32/name +32282 0x11/imm32/alloc-id:fake +32283 Type-literal/imm32 +32284 1/imm32/some-block-depth +32285 0/imm32/no-stack-offset +32286 0/imm32/no-register +32287 0/imm32/no-register +32288 +32289 Single-float-var-in-mem: # (payload list var) +32290 0x11/imm32/alloc-id:fake:payload +32291 0x11/imm32/alloc-id:fake +32292 Float-var-in-mem/imm32 +32293 0/imm32/next +32294 0/imm32/next +32295 +32296 Float-var-in-mem: # (payload var) +32297 0x11/imm32/alloc-id:fake:payload +32298 0/imm32/name +32299 0/imm32/name +32300 0x11/imm32/alloc-id:fake +32301 Type-float/imm32 +32302 1/imm32/some-block-depth +32303 1/imm32/some-stack-offset +32304 0/imm32/no-register +32305 0/imm32/no-register 32306 -32307 is-mu-addr-type?: # a: (addr type-tree) -> result/eax: boolean -32308 # . prologue -32309 55/push-ebp -32310 89/<- %ebp 4/r32/esp -32311 # eax = a -32312 8b/-> *(ebp+8) 0/r32/eax -32313 # if (!a->is-atom?) a = a->left -32314 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -32315 { -32316 75/jump-if-!= break/disp8 -32317 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -32318 } -32319 # return (a->value == addr) -32320 81 7/subop/compare *(eax+4) 2/imm32/addr # Type-tree-value -32321 0f 94/set-byte-if-= %al -32322 81 4/subop/and %eax 0xff/imm32 -32323 $is-mu-addr-type?:end: -32324 # . epilogue -32325 89/<- %esp 5/r32/ebp -32326 5d/pop-to-ebp -32327 c3/return -32328 -32329 is-mu-array-type?: # a: (addr type-tree) -> result/eax: boolean -32330 # . prologue -32331 55/push-ebp -32332 89/<- %ebp 4/r32/esp -32333 # eax = a -32334 8b/-> *(ebp+8) 0/r32/eax -32335 # if (!a->is-atom?) a = a->left -32336 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -32337 { -32338 75/jump-if-!= break/disp8 -32339 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -32340 } -32341 # return (a->value == array) -32342 81 7/subop/compare *(eax+4) 3/imm32/array # Type-tree-value -32343 0f 94/set-byte-if-= %al -32344 81 4/subop/and %eax 0xff/imm32 -32345 $is-mu-array-type?:end: -32346 # . epilogue -32347 89/<- %esp 5/r32/ebp -32348 5d/pop-to-ebp -32349 c3/return -32350 -32351 is-mu-string-type?: # a: (addr type-tree) -> result/eax: boolean -32352 # . prologue -32353 55/push-ebp -32354 89/<- %ebp 4/r32/esp -32355 # . save registers -32356 56/push-esi -32357 # esi = a -32358 8b/-> *(ebp+8) 6/r32/esi -32359 # if (a->is-atom?) return false -32360 81 7/subop/compare *esi 0/imm32/false # Type-tree-is-atom -32361 0f 85/jump-if-!= $is-mu-string-type?:return-false/disp32 -32362 # if a is not an addr, return false -32363 (is-mu-addr-type? %esi) # => eax -32364 3d/compare-eax-with 0/imm32/false -32365 0f 84/jump-if-= $is-mu-string-type?:end/disp32 # eax changes var -32366 # if a is not an array, return false -32367 (lookup *(esi+0xc) *(esi+0x10)) # Type-tree-right Type-tree-right => eax -32368 (is-mu-array-type? %eax) # => eax -32369 3d/compare-eax-with 0/imm32/false -32370 74/jump-if-= $is-mu-string-type?:end/disp8 # eax changes var -32371 # var p/eax: (addr type-tree) = payload of a -32372 (lookup *(esi+0xc) *(esi+0x10)) # Type-tree-right Type-tree-right => eax -32373 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax -32374 # if p is an atom, return false -32375 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -32376 75/jump-if-!= $is-mu-string-type?:return-false/disp8 -32377 # return (p == byte) -32378 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -32379 (is-simple-mu-type? %eax 8) # byte => eax -32380 eb/jump $is-mu-string-type?:end/disp8 -32381 $is-mu-string-type?:return-false: -32382 b8/copy-to-eax 0/imm32/false -32383 $is-mu-string-type?:end: -32384 # . restore registers -32385 5e/pop-to-esi -32386 # . epilogue -32387 89/<- %esp 5/r32/ebp -32388 5d/pop-to-ebp -32389 c3/return -32390 -32391 is-mu-stream-type?: # a: (addr type-tree) -> result/eax: boolean -32392 # . prologue -32393 55/push-ebp -32394 89/<- %ebp 4/r32/esp -32395 # eax = a -32396 8b/-> *(ebp+8) 0/r32/eax -32397 # if (!a->is-atom?) a = a->left -32398 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom -32399 { -32400 75/jump-if-!= break/disp8 -32401 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax -32402 } -32403 # return (a->value == stream) -32404 81 7/subop/compare *(eax+4) 0xb/imm32/stream # Type-tree-value -32405 0f 94/set-byte-if-= %al -32406 81 4/subop/and %eax 0xff/imm32 -32407 $is-mu-stream-type?:end: -32408 # . epilogue -32409 89/<- %esp 5/r32/ebp -32410 5d/pop-to-ebp -32411 c3/return -32412 -32413 test-emit-subx-stmt-primitive: -32414 # Primitive operation on a variable on the stack. -32415 # increment foo -32416 # => -32417 # ff 0/subop/increment *(ebp-8) -32418 # -32419 # There's a variable on the var stack as follows: -32420 # name: 'foo' -32421 # type: int -32422 # stack-offset: -8 -32423 # -32424 # There's a primitive with this info: -32425 # name: 'increment' -32426 # inouts: int/mem -32427 # value: 'ff 0/subop/increment' -32428 # -32429 # . prologue -32430 55/push-ebp -32431 89/<- %ebp 4/r32/esp -32432 # setup -32433 (clear-stream _test-output-stream) -32434 (clear-stream $_test-output-buffered-file->buffer) -32435 # simulate allocated payloads starting with an initial fake alloc-id (0x11) -32436 $test-emit-subx-stmt-primitive:initialize-type: -32437 # var type/ecx: (payload type-tree) = int -32438 68/push 0/imm32/right:null -32439 68/push 0/imm32/right:null -32440 68/push 0/imm32/left:unused -32441 68/push 1/imm32/value:int -32442 68/push 1/imm32/is-atom?:true -32443 68/push 0x11/imm32/alloc-id:fake:payload -32444 89/<- %ecx 4/r32/esp -32445 $test-emit-subx-stmt-primitive:initialize-var: -32446 # var var-foo/ecx: (payload var) = var(type) -32447 68/push 0/imm32/no-register -32448 68/push 0/imm32/no-register -32449 68/push -8/imm32/stack-offset -32450 68/push 1/imm32/block-depth -32451 51/push-ecx/type -32452 68/push 0x11/imm32/alloc-id:fake -32453 68/push 0/imm32/name -32454 68/push 0/imm32/name -32455 68/push 0x11/imm32/alloc-id:fake:payload -32456 89/<- %ecx 4/r32/esp -32457 $test-emit-subx-stmt-primitive:initialize-var-name: -32458 # var-foo->name = "foo" -32459 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -32460 (copy-array Heap "foo" %eax) -32461 $test-emit-subx-stmt-primitive:initialize-stmt-var: -32462 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) -32463 68/push 0/imm32/is-deref:false -32464 68/push 0/imm32/next -32465 68/push 0/imm32/next -32466 51/push-ecx/var-foo -32467 68/push 0x11/imm32/alloc-id:fake -32468 68/push 0x11/imm32/alloc-id:fake:payload -32469 89/<- %ebx 4/r32/esp -32470 $test-emit-subx-stmt-primitive:initialize-stmt: -32471 # var stmt/esi: (addr statement) -32472 68/push 0/imm32/no-outputs -32473 68/push 0/imm32/no-outputs -32474 53/push-ebx/inouts -32475 68/push 0x11/imm32/alloc-id:fake -32476 68/push 0/imm32/operation -32477 68/push 0/imm32/operation -32478 68/push 1/imm32/tag -32479 89/<- %esi 4/r32/esp -32480 $test-emit-subx-stmt-primitive:initialize-stmt-operation: -32481 # stmt->operation = "increment" -32482 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -32483 (copy-array Heap "increment" %eax) -32484 $test-emit-subx-stmt-primitive:initialize-primitive: -32485 # var primitives/ebx: (addr primitive) -32486 68/push 0/imm32/next -32487 68/push 0/imm32/next -32488 68/push 0/imm32/no-x32 -32489 68/push 0/imm32/no-xm32 -32490 68/push 0/imm32/no-disp32 -32491 68/push 0/imm32/no-imm8 -32492 68/push 0/imm32/no-imm32 -32493 68/push 0/imm32/no-r32 -32494 68/push 1/imm32/rm32-is-first-inout -32495 68/push 0/imm32/subx-name -32496 68/push 0/imm32/subx-name -32497 68/push 0/imm32/no-outputs -32498 68/push 0/imm32/no-outputs -32499 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration -32500 68/push 0x11/imm32/alloc-id:fake -32501 68/push 0/imm32/name -32502 68/push 0/imm32/name -32503 89/<- %ebx 4/r32/esp -32504 $test-emit-subx-stmt-primitive:initialize-primitive-name: -32505 # primitives->name = "increment" -32506 (copy-array Heap "increment" %ebx) # Primitive-name -32507 $test-emit-subx-stmt-primitive:initialize-primitive-subx-name: -32508 # primitives->subx-name = "ff 0/subop/increment" -32509 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -32510 (copy-array Heap "ff 0/subop/increment" %eax) -32511 # convert -32512 c7 0/subop/copy *Curr-block-depth 0/imm32 -32513 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) -32514 (flush _test-output-buffered-file) -32515 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -32521 # check output -32522 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment *(ebp+0xfffffff8)" "F - test-emit-subx-stmt-primitive") -32523 # . epilogue -32524 89/<- %esp 5/r32/ebp -32525 5d/pop-to-ebp -32526 c3/return -32527 -32528 test-emit-subx-stmt-primitive-register: -32529 # Primitive operation on a variable in a register. -32530 # foo <- increment -32531 # => -32532 # ff 0/subop/increment %eax # sub-optimal, but should suffice -32533 # -32534 # There's a variable on the var stack as follows: -32535 # name: 'foo' -32536 # type: int -32537 # register: 'eax' -32538 # -32539 # There's a primitive with this info: -32540 # name: 'increment' -32541 # out: int/reg -32542 # value: 'ff 0/subop/increment' -32543 # -32544 # . prologue -32545 55/push-ebp -32546 89/<- %ebp 4/r32/esp -32547 # setup -32548 (clear-stream _test-output-stream) -32549 (clear-stream $_test-output-buffered-file->buffer) -32550 $test-emit-subx-stmt-primitive-register:initialize-type: -32551 # var type/ecx: (payload type-tree) = int -32552 68/push 0/imm32/right:null -32553 68/push 0/imm32/right:null -32554 68/push 0/imm32/left:unused -32555 68/push 1/imm32/value:int -32556 68/push 1/imm32/is-atom?:true -32557 68/push 0x11/imm32/alloc-id:fake:payload -32558 89/<- %ecx 4/r32/esp -32559 $test-emit-subx-stmt-primitive-register:initialize-var: -32560 # var var-foo/ecx: (payload var) -32561 68/push 0/imm32/register -32562 68/push 0/imm32/register -32563 68/push 0/imm32/no-stack-offset -32564 68/push 1/imm32/block-depth -32565 51/push-ecx -32566 68/push 0x11/imm32/alloc-id:fake -32567 68/push 0/imm32/name -32568 68/push 0/imm32/name -32569 68/push 0x11/imm32/alloc-id:fake:payload -32570 89/<- %ecx 4/r32/esp -32571 $test-emit-subx-stmt-primitive-register:initialize-var-name: -32572 # var-foo->name = "foo" -32573 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -32574 (copy-array Heap "foo" %eax) -32575 $test-emit-subx-stmt-primitive-register:initialize-var-register: -32576 # var-foo->register = "eax" -32577 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -32578 (copy-array Heap "eax" %eax) -32579 $test-emit-subx-stmt-primitive-register:initialize-stmt-var: -32580 # var operand/ebx: (payload stmt-var) -32581 68/push 0/imm32/is-deref:false -32582 68/push 0/imm32/next -32583 68/push 0/imm32/next -32584 51/push-ecx/var-foo -32585 68/push 0x11/imm32/alloc-id:fake -32586 68/push 0x11/imm32/alloc-id:fake:payload -32587 89/<- %ebx 4/r32/esp -32588 $test-emit-subx-stmt-primitive-register:initialize-stmt: -32589 # var stmt/esi: (addr statement) -32590 53/push-ebx/outputs -32591 68/push 0x11/imm32/alloc-id:fake -32592 68/push 0/imm32/no-inouts -32593 68/push 0/imm32/no-inouts -32594 68/push 0/imm32/operation -32595 68/push 0/imm32/operation -32596 68/push 1/imm32 -32597 89/<- %esi 4/r32/esp -32598 $test-emit-subx-stmt-primitive-register:initialize-stmt-operation: -32599 # stmt->operation = "increment" -32600 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -32601 (copy-array Heap "increment" %eax) -32602 $test-emit-subx-stmt-primitive-register:initialize-formal-var: -32603 # var formal-var/ebx: (payload var) -32604 68/push 0/imm32/register -32605 68/push 0/imm32/register -32606 68/push 0/imm32/no-stack-offset -32607 68/push 1/imm32/block-depth -32608 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id -32609 68/push 0x11/imm32/alloc-id:fake -32610 68/push 0/imm32/name -32611 68/push 0/imm32/name -32612 68/push 0x11/imm32/alloc-id:fake:payload -32613 89/<- %ebx 4/r32/esp -32614 $test-emit-subx-stmt-primitive-register:initialize-formal-var-name: -32615 # formal-var->name = "dummy" -32616 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 -32617 (copy-array Heap "dummy" %eax) -32618 $test-emit-subx-stmt-primitive-register:initialize-formal-register: -32619 # formal-var->register = "*" -32620 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 -32621 (copy-array Heap "*" %eax) # Any-register -32622 $test-emit-subx-stmt-primitive-register:initialize-var-list: -32623 # var formal-outputs/ebx: (payload list var) -32624 68/push 0/imm32/next -32625 68/push 0/imm32/next -32626 53/push-ebx/formal-var -32627 68/push 0x11/imm32/alloc-id:fake -32628 68/push 0x11/imm32/alloc-id:fake:payload -32629 89/<- %ebx 4/r32/esp -32630 $test-emit-subx-stmt-primitive-register:initialize-primitive: -32631 # var primitives/ebx: (addr primitive) -32632 68/push 0/imm32/next -32633 68/push 0/imm32/next -32634 68/push 0/imm32/no-x32 -32635 68/push 0/imm32/no-xm32 -32636 68/push 0/imm32/no-disp32 -32637 68/push 0/imm32/no-imm8 -32638 68/push 0/imm32/no-imm32 -32639 68/push 0/imm32/no-r32 -32640 68/push 3/imm32/rm32-is-first-output -32641 68/push 0/imm32/subx-name -32642 68/push 0/imm32/subx-name -32643 53/push-ebx/outputs -32644 68/push 0x11/imm32/alloc-id:fake -32645 68/push 0/imm32/no-inouts -32646 68/push 0/imm32/no-inouts -32647 68/push 0/imm32/name -32648 68/push 0/imm32/name -32649 89/<- %ebx 4/r32/esp -32650 $test-emit-subx-stmt-primitive-register:initialize-primitive-name: -32651 # primitives->name = "increment" -32652 (copy-array Heap "increment" %ebx) # Primitive-name -32653 $test-emit-subx-stmt-primitive-register:initialize-primitive-subx-name: -32654 # primitives->subx-name = "ff 0/subop/increment" -32655 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -32656 (copy-array Heap "ff 0/subop/increment" %eax) -32657 # convert -32658 c7 0/subop/copy *Curr-block-depth 0/imm32 -32659 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) -32660 (flush _test-output-buffered-file) -32661 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -32667 # check output -32668 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-primitive-register") +32307 Single-float-var-in-some-register: # (payload list var) +32308 0x11/imm32/alloc-id:fake:payload +32309 0x11/imm32/alloc-id:fake +32310 Float-var-in-some-register/imm32 +32311 0/imm32/next +32312 0/imm32/next +32313 +32314 Float-var-in-some-register: # (payload var) +32315 0x11/imm32/alloc-id:fake:payload +32316 0/imm32/name +32317 0/imm32/name +32318 0x11/imm32/alloc-id:fake +32319 Type-float/imm32 +32320 1/imm32/some-block-depth +32321 0/imm32/no-stack-offset +32322 0x11/imm32/alloc-id:fake +32323 Any-register/imm32 +32324 +32325 Type-int: # (payload type-tree) +32326 0x11/imm32/alloc-id:fake:payload +32327 1/imm32/is-atom +32328 1/imm32/value:int +32329 0/imm32/left:unused +32330 0/imm32/right:null +32331 0/imm32/right:null +32332 +32333 Type-literal: # (payload type-tree) +32334 0x11/imm32/alloc-id:fake:payload +32335 1/imm32/is-atom +32336 0/imm32/value:literal +32337 0/imm32/left:unused +32338 0/imm32/right:null +32339 0/imm32/right:null +32340 +32341 Type-addr: # (payload type-tree) +32342 0x11/imm32/alloc-id:fake:payload +32343 1/imm32/is-atom +32344 2/imm32/value:addr +32345 0/imm32/left:unused +32346 0/imm32/right:null +32347 0/imm32/right:null +32348 +32349 Type-byte: # (payload type-tree) +32350 0x11/imm32/alloc-id:fake:payload +32351 1/imm32/is-atom +32352 8/imm32/value:byte +32353 0/imm32/left:unused +32354 0/imm32/right:null +32355 0/imm32/right:null +32356 +32357 Type-float: # (payload type-tree) +32358 0x11/imm32/alloc-id:fake:payload +32359 1/imm32/is-atom +32360 0xf/imm32/value:float +32361 0/imm32/left:unused +32362 0/imm32/right:null +32363 0/imm32/right:null +32364 +32365 == code +32366 emit-subx-primitive: # out: (addr buffered-file), stmt: (addr stmt), primitive: (addr primitive), err: (addr buffered-file), ed: (addr exit-descriptor) +32367 # . prologue +32368 55/push-ebp +32369 89/<- %ebp 4/r32/esp +32370 # . save registers +32371 50/push-eax +32372 51/push-ecx +32373 # ecx = primitive +32374 8b/-> *(ebp+0x10) 1/r32/ecx +32375 # emit primitive name +32376 (emit-indent *(ebp+8) *Curr-block-depth) +32377 (lookup *(ecx+0x18) *(ecx+0x1c)) # Primitive-subx-name Primitive-subx-name => eax +32378 (write-buffered *(ebp+8) %eax) +32379 # emit rm32 if necessary +32380 (emit-subx-rm32 *(ebp+8) *(ecx+0x20) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-rm32 +32381 # emit xm32 if necessary +32382 (emit-subx-rm32 *(ebp+8) *(ecx+0x34) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-xm32 +32383 # emit r32 if necessary +32384 (emit-subx-r32 *(ebp+8) *(ecx+0x24) *(ebp+0xc)) # Primitive-subx-r32 +32385 # emit x32 if necessary +32386 (emit-subx-x32 *(ebp+8) *(ecx+0x38) *(ebp+0xc)) # Primitive-subx-x32 +32387 # emit imm32 if necessary +32388 (emit-subx-imm32 *(ebp+8) *(ecx+0x28) *(ebp+0xc)) # Primitive-subx-imm32 +32389 # emit imm8 if necessary +32390 (emit-subx-imm8 *(ebp+8) *(ecx+0x2c) *(ebp+0xc)) # Primitive-subx-imm8 +32391 # emit disp32 if necessary +32392 (emit-subx-disp32 *(ebp+8) *(ecx+0x30) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # Primitive-subx-disp32 +32393 (write-buffered *(ebp+8) Newline) +32394 $emit-subx-primitive:end: +32395 # . restore registers +32396 59/pop-to-ecx +32397 58/pop-to-eax +32398 # . epilogue +32399 89/<- %esp 5/r32/ebp +32400 5d/pop-to-ebp +32401 c3/return +32402 +32403 emit-subx-rm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +32404 # . prologue +32405 55/push-ebp +32406 89/<- %ebp 4/r32/esp +32407 # . save registers +32408 50/push-eax +32409 # if (l == 0) return +32410 81 7/subop/compare *(ebp+0xc) 0/imm32 +32411 74/jump-if-= $emit-subx-rm32:end/disp8 +32412 # var v/eax: (addr stmt-var) +32413 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # => eax +32414 (emit-subx-var-as-rm32 *(ebp+8) %eax) +32415 $emit-subx-rm32:end: +32416 # . restore registers +32417 58/pop-to-eax +32418 # . epilogue +32419 89/<- %esp 5/r32/ebp +32420 5d/pop-to-ebp +32421 c3/return +32422 +32423 get-stmt-operand-from-arg-location: # stmt: (addr stmt), l: arg-location, err: (addr buffered-file), ed: (addr exit-descriptor) -> var/eax: (addr stmt-var) +32424 # . prologue +32425 55/push-ebp +32426 89/<- %ebp 4/r32/esp +32427 # . save registers +32428 51/push-ecx +32429 # eax = l +32430 8b/-> *(ebp+0xc) 0/r32/eax +32431 # ecx = stmt +32432 8b/-> *(ebp+8) 1/r32/ecx +32433 # if (l == 1) return stmt->inouts +32434 { +32435 3d/compare-eax-and 1/imm32 +32436 75/jump-if-!= break/disp8 +32437 $get-stmt-operand-from-arg-location:1: +32438 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +32439 eb/jump $get-stmt-operand-from-arg-location:end/disp8 +32440 } +32441 # if (l == 2) return stmt->inouts->next +32442 { +32443 3d/compare-eax-and 2/imm32 +32444 75/jump-if-!= break/disp8 +32445 $get-stmt-operand-from-arg-location:2: +32446 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +32447 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +32448 eb/jump $get-stmt-operand-from-arg-location:end/disp8 +32449 } +32450 # if (l == 3) return stmt->outputs +32451 { +32452 3d/compare-eax-and 3/imm32 +32453 75/jump-if-!= break/disp8 +32454 $get-stmt-operand-from-arg-location:3: +32455 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +32456 eb/jump $get-stmt-operand-from-arg-location:end/disp8 +32457 } +32458 # abort +32459 e9/jump $get-stmt-operand-from-arg-location:abort/disp32 +32460 $get-stmt-operand-from-arg-location:end: +32461 # . restore registers +32462 59/pop-to-ecx +32463 # . epilogue +32464 89/<- %esp 5/r32/ebp +32465 5d/pop-to-ebp +32466 c3/return +32467 +32468 $get-stmt-operand-from-arg-location:abort: +32469 # error("invalid arg-location " eax) +32470 (write-buffered *(ebp+0x10) "invalid arg-location ") +32471 (write-int32-hex-buffered *(ebp+0x10) %eax) +32472 (write-buffered *(ebp+0x10) Newline) +32473 (flush *(ebp+0x10)) +32474 (stop *(ebp+0x14) 1) +32475 # never gets here +32476 +32477 emit-subx-r32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +32478 # . prologue +32479 55/push-ebp +32480 89/<- %ebp 4/r32/esp +32481 # . save registers +32482 50/push-eax +32483 51/push-ecx +32484 # if (l == 0) return +32485 81 7/subop/compare *(ebp+0xc) 0/imm32 +32486 0f 84/jump-if-= $emit-subx-r32:end/disp32 +32487 # var v/eax: (addr stmt-var) +32488 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +32489 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +32490 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +32491 #? (write-buffered Stderr "looking up ") +32492 #? (write-buffered Stderr %eax) +32493 #? (write-buffered Stderr Newline) +32494 #? (flush Stderr) +32495 (maybe-get Mu-registers %eax 0xc) # => eax: (addr register-index) +32496 (write-buffered *(ebp+8) Space) +32497 (write-int32-hex-buffered *(ebp+8) *eax) +32498 (write-buffered *(ebp+8) "/r32") +32499 $emit-subx-r32:end: +32500 # . restore registers +32501 59/pop-to-ecx +32502 58/pop-to-eax +32503 # . epilogue +32504 89/<- %esp 5/r32/ebp +32505 5d/pop-to-ebp +32506 c3/return +32507 +32508 emit-subx-x32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +32509 # . prologue +32510 55/push-ebp +32511 89/<- %ebp 4/r32/esp +32512 # . save registers +32513 50/push-eax +32514 51/push-ecx +32515 # if (l == 0) return +32516 81 7/subop/compare *(ebp+0xc) 0/imm32 +32517 0f 84/jump-if-= $emit-subx-x32:end/disp32 +32518 # var v/eax: (addr stmt-var) +32519 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +32520 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +32521 (lookup *(eax+0x18) *(eax+0x1c)) # Var-register Var-register => eax +32522 #? (write-buffered Stderr "looking up ") +32523 #? (write-buffered Stderr %eax) +32524 #? (write-buffered Stderr Newline) +32525 #? (flush Stderr) +32526 (maybe-get Mu-registers %eax 0xc) # => eax: (addr register-index) +32527 (write-buffered *(ebp+8) Space) +32528 (write-int32-hex-buffered *(ebp+8) *eax) +32529 (write-buffered *(ebp+8) "/x32") +32530 $emit-subx-x32:end: +32531 # . restore registers +32532 59/pop-to-ecx +32533 58/pop-to-eax +32534 # . epilogue +32535 89/<- %esp 5/r32/ebp +32536 5d/pop-to-ebp +32537 c3/return +32538 +32539 emit-subx-imm32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +32540 # . prologue +32541 55/push-ebp +32542 89/<- %ebp 4/r32/esp +32543 # . save registers +32544 50/push-eax +32545 51/push-ecx +32546 # if (l == 0) return +32547 81 7/subop/compare *(ebp+0xc) 0/imm32 +32548 0f 84/jump-if-= $emit-subx-imm32:end/disp32 +32549 # var v/eax: (handle var) +32550 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +32551 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +32552 (lookup *eax *(eax+4)) # Var-name Var-name => eax +32553 (write-buffered *(ebp+8) Space) +32554 (write-buffered *(ebp+8) %eax) +32555 (write-buffered *(ebp+8) "/imm32") +32556 $emit-subx-imm32:end: +32557 # . restore registers +32558 59/pop-to-ecx +32559 58/pop-to-eax +32560 # . epilogue +32561 89/<- %esp 5/r32/ebp +32562 5d/pop-to-ebp +32563 c3/return +32564 +32565 emit-subx-imm8: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt) +32566 # . prologue +32567 55/push-ebp +32568 89/<- %ebp 4/r32/esp +32569 # . save registers +32570 50/push-eax +32571 51/push-ecx +32572 # if (l == 0) return +32573 81 7/subop/compare *(ebp+0xc) 0/imm32 +32574 0f 84/jump-if-= $emit-subx-imm32:end/disp32 +32575 # var v/eax: (handle var) +32576 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc)) # => eax +32577 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +32578 (lookup *eax *(eax+4)) # Var-name Var-name => eax +32579 (write-buffered *(ebp+8) Space) +32580 (write-buffered *(ebp+8) %eax) +32581 (write-buffered *(ebp+8) "/imm8") +32582 $emit-subx-imm8:end: +32583 # . restore registers +32584 59/pop-to-ecx +32585 58/pop-to-eax +32586 # . epilogue +32587 89/<- %esp 5/r32/ebp +32588 5d/pop-to-ebp +32589 c3/return +32590 +32591 emit-subx-disp32: # out: (addr buffered-file), l: arg-location, stmt: (addr stmt), err: (addr buffered-file), ed: (addr exit-descriptor) +32592 # . prologue +32593 55/push-ebp +32594 89/<- %ebp 4/r32/esp +32595 # . save registers +32596 50/push-eax +32597 51/push-ecx +32598 # if (location == 0) return +32599 81 7/subop/compare *(ebp+0xc) 0/imm32 +32600 0f 84/jump-if-= $emit-subx-disp32:end/disp32 +32601 # var v/eax: (addr stmt-var) +32602 (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc) *(ebp+0x14) *(ebp+0x18)) # => eax +32603 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax +32604 (lookup *eax *(eax+4)) # Var-name Var-name => eax +32605 (write-buffered *(ebp+8) Space) +32606 (write-buffered *(ebp+8) %eax) +32607 # hack: if instruction operation starts with "break", emit ":break" +32608 # var name/ecx: (addr array byte) = lookup(stmt->operation) +32609 8b/-> *(ebp+0x10) 0/r32/eax +32610 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +32611 89/<- %ecx 0/r32/eax +32612 { +32613 (string-starts-with? %ecx "break") # => eax +32614 3d/compare-eax-and 0/imm32/false +32615 74/jump-if-= break/disp8 +32616 (write-buffered *(ebp+8) ":break") +32617 } +32618 # hack: if instruction operation starts with "loop", emit ":loop" +32619 { +32620 (string-starts-with? %ecx "loop") # => eax +32621 3d/compare-eax-and 0/imm32/false +32622 74/jump-if-= break/disp8 +32623 (write-buffered *(ebp+8) ":loop") +32624 } +32625 (write-buffered *(ebp+8) "/disp32") +32626 $emit-subx-disp32:end: +32627 # . restore registers +32628 59/pop-to-ecx +32629 58/pop-to-eax +32630 # . epilogue +32631 89/<- %esp 5/r32/ebp +32632 5d/pop-to-ebp +32633 c3/return +32634 +32635 emit-call: # out: (addr buffered-file), stmt: (addr stmt) +32636 # . prologue +32637 55/push-ebp +32638 89/<- %ebp 4/r32/esp +32639 # . save registers +32640 50/push-eax +32641 51/push-ecx +32642 # +32643 (emit-indent *(ebp+8) *Curr-block-depth) +32644 (write-buffered *(ebp+8) "(") +32645 # ecx = stmt +32646 8b/-> *(ebp+0xc) 1/r32/ecx +32647 # - emit function name +32648 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +32649 (write-buffered *(ebp+8) %eax) +32650 # - emit arguments +32651 # var curr/eax: (addr stmt-var) = lookup(stmt->inouts) +32652 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +32653 { +32654 # if (curr == null) break +32655 3d/compare-eax-and 0/imm32 +32656 74/jump-if-= break/disp8 +32657 # +32658 (emit-subx-call-operand *(ebp+8) %eax) +32659 # curr = lookup(curr->next) +32660 (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax +32661 eb/jump loop/disp8 +32662 } +32663 # +32664 (write-buffered *(ebp+8) ")\n") +32665 $emit-call:end: +32666 # . restore registers +32667 59/pop-to-ecx +32668 58/pop-to-eax 32669 # . epilogue 32670 89/<- %esp 5/r32/ebp 32671 5d/pop-to-ebp 32672 c3/return 32673 -32674 test-emit-subx-stmt-select-primitive: -32675 # Select the right primitive between overloads. -32676 # foo <- increment -32677 # => -32678 # ff 0/subop/increment %eax # sub-optimal, but should suffice -32679 # -32680 # There's a variable on the var stack as follows: -32681 # name: 'foo' -32682 # type: int -32683 # register: 'eax' -32684 # -32685 # There's two primitives, as follows: -32686 # - name: 'increment' -32687 # out: int/reg -32688 # value: 'ff 0/subop/increment' -32689 # - name: 'increment' -32690 # inout: int/mem -32691 # value: 'ff 0/subop/increment' -32692 # -32693 # . prologue -32694 55/push-ebp -32695 89/<- %ebp 4/r32/esp -32696 # setup -32697 (clear-stream _test-output-stream) -32698 (clear-stream $_test-output-buffered-file->buffer) -32699 $test-emit-subx-stmt-select-primitive:initialize-type: -32700 # var type/ecx: (payload type-tree) = int -32701 68/push 0/imm32/right:null -32702 68/push 0/imm32/right:null -32703 68/push 0/imm32/left:unused -32704 68/push 1/imm32/value:int -32705 68/push 1/imm32/is-atom?:true -32706 68/push 0x11/imm32/alloc-id:fake:payload -32707 89/<- %ecx 4/r32/esp -32708 $test-emit-subx-stmt-select-primitive:initialize-var: -32709 # var var-foo/ecx: (payload var) -32710 68/push 0/imm32/register -32711 68/push 0/imm32/register -32712 68/push 0/imm32/no-stack-offset -32713 68/push 1/imm32/block-depth -32714 51/push-ecx -32715 68/push 0x11/imm32/alloc-id:fake -32716 68/push 0/imm32/name -32717 68/push 0/imm32/name -32718 68/push 0x11/imm32/alloc-id:fake:payload -32719 89/<- %ecx 4/r32/esp -32720 $test-emit-subx-stmt-select-primitive:initialize-var-name: -32721 # var-foo->name = "foo" -32722 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -32723 (copy-array Heap "foo" %eax) -32724 $test-emit-subx-stmt-select-primitive:initialize-var-register: -32725 # var-foo->register = "eax" -32726 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -32727 (copy-array Heap "eax" %eax) -32728 $test-emit-subx-stmt-select-primitive:initialize-stmt-var: -32729 # var operand/ebx: (payload stmt-var) -32730 68/push 0/imm32/is-deref:false -32731 68/push 0/imm32/next -32732 68/push 0/imm32/next -32733 51/push-ecx/var-foo -32734 68/push 0x11/imm32/alloc-id:fake -32735 68/push 0x11/imm32/alloc-id:fake:payload -32736 89/<- %ebx 4/r32/esp -32737 $test-emit-subx-stmt-select-primitive:initialize-stmt: -32738 # var stmt/esi: (addr statement) -32739 53/push-ebx/outputs -32740 68/push 0x11/imm32/alloc-id:fake -32741 68/push 0/imm32/no-inouts -32742 68/push 0/imm32/no-inouts -32743 68/push 0/imm32/operation -32744 68/push 0/imm32/operation -32745 68/push 1/imm32 -32746 89/<- %esi 4/r32/esp -32747 $test-emit-subx-stmt-select-primitive:initialize-stmt-operation: -32748 # stmt->operation = "increment" -32749 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -32750 (copy-array Heap "increment" %eax) -32751 $test-emit-subx-stmt-select-primitive:initialize-formal-var: -32752 # var formal-var/ebx: (payload var) -32753 68/push 0/imm32/register -32754 68/push 0/imm32/register -32755 68/push 0/imm32/no-stack-offset -32756 68/push 1/imm32/block-depth -32757 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id -32758 68/push 0x11/imm32/alloc-id:fake -32759 68/push 0/imm32/name -32760 68/push 0/imm32/name -32761 68/push 0x11/imm32/alloc-id:fake:payload -32762 89/<- %ebx 4/r32/esp -32763 $test-emit-subx-stmt-select-primitive:initialize-formal-var-name: -32764 # formal-var->name = "dummy" -32765 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 -32766 (copy-array Heap "dummy" %eax) -32767 $test-emit-subx-stmt-select-primitive:initialize-formal-register: -32768 # formal-var->register = "*" -32769 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 -32770 (copy-array Heap "*" %eax) # Any-register -32771 $test-emit-subx-stmt-select-primitive:initialize-var-list: -32772 # var formal-outputs/ebx: (payload list var) -32773 68/push 0/imm32/next -32774 68/push 0/imm32/next -32775 53/push-ebx/formal-var -32776 68/push 0x11/imm32/alloc-id:fake -32777 68/push 0x11/imm32/alloc-id:fake:payload -32778 89/<- %ebx 4/r32/esp -32779 $test-emit-subx-stmt-select-primitive:initialize-primitive2: -32780 # var primitive2/edi: (payload primitive) -32781 68/push 0/imm32/next -32782 68/push 0/imm32/next -32783 68/push 0/imm32/no-x32 -32784 68/push 0/imm32/no-xm32 -32785 68/push 0/imm32/no-disp32 -32786 68/push 0/imm32/no-imm8 -32787 68/push 0/imm32/no-imm32 -32788 68/push 0/imm32/no-r32 -32789 68/push 3/imm32/rm32-is-first-output -32790 68/push 0/imm32/subx-name -32791 68/push 0/imm32/subx-name -32792 53/push-ebx/outputs -32793 68/push 0x11/imm32/alloc-id:fake -32794 68/push 0/imm32/no-inouts -32795 68/push 0/imm32/no-inouts -32796 68/push 0/imm32/name -32797 68/push 0/imm32/name -32798 68/push 0x11/imm32/alloc-id:fake:payload -32799 89/<- %edi 4/r32/esp -32800 $test-emit-subx-stmt-select-primitive:initialize-primitive2-name: -32801 # primitives->name = "increment" -32802 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 -32803 (copy-array Heap "increment" %eax) -32804 $test-emit-subx-stmt-select-primitive:initialize-primitive2-subx-name: -32805 # primitives->subx-name = "ff 0/subop/increment" -32806 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 -32807 (copy-array Heap "ff 0/subop/increment" %eax) -32808 $test-emit-subx-stmt-select-primitive:initialize-primitive: -32809 # var primitives/ebx: (addr primitive) -32810 57/push-edi -32811 68/push 0x11/imm32/alloc-id:fake -32812 68/push 0/imm32/no-x32 -32813 68/push 0/imm32/no-xm32 -32814 68/push 0/imm32/no-disp32 -32815 68/push 0/imm32/no-imm8 -32816 68/push 0/imm32/no-imm32 -32817 68/push 0/imm32/no-r32 -32818 68/push 1/imm32/rm32-is-first-inout -32819 68/push 0/imm32/subx-name -32820 68/push 0/imm32/subx-name -32821 68/push 0/imm32/no-outputs -32822 68/push 0/imm32/no-outputs -32823 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration -32824 68/push 0x11/imm32/alloc-id:fake -32825 68/push 0/imm32/name -32826 68/push 0/imm32/name -32827 89/<- %ebx 4/r32/esp -32828 $test-emit-subx-stmt-select-primitive:initialize-primitive-name: -32829 # primitives->name = "increment" -32830 (copy-array Heap "increment" %ebx) # Primitive-name -32831 $test-emit-subx-stmt-select-primitive:initialize-primitive-subx-name: -32832 # primitives->subx-name = "ff 0/subop/increment" -32833 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -32834 (copy-array Heap "ff 0/subop/increment" %eax) -32835 # convert -32836 c7 0/subop/copy *Curr-block-depth 0/imm32 -32837 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) -32838 (flush _test-output-buffered-file) -32839 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -32845 # check output -32846 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive") -32847 # . epilogue -32848 89/<- %esp 5/r32/ebp -32849 5d/pop-to-ebp -32850 c3/return -32851 -32852 test-emit-subx-stmt-select-primitive-2: -32853 # Select the right primitive between overloads. -32854 # increment foo -32855 # => -32856 # ff 0/subop/increment %eax # sub-optimal, but should suffice -32857 # -32858 # There's a variable on the var stack as follows: -32859 # name: 'foo' -32860 # type: int -32861 # register: 'eax' -32862 # -32863 # There's two primitives, as follows: -32864 # - name: 'increment' -32865 # out: int/reg -32866 # value: 'ff 0/subop/increment' -32867 # - name: 'increment' -32868 # inout: int/mem -32869 # value: 'ff 0/subop/increment' -32870 # -32871 # . prologue -32872 55/push-ebp -32873 89/<- %ebp 4/r32/esp -32874 # setup -32875 (clear-stream _test-output-stream) -32876 (clear-stream $_test-output-buffered-file->buffer) -32877 $test-emit-subx-stmt-select-primitive-2:initialize-type: -32878 # var type/ecx: (payload type-tree) = int -32879 68/push 0/imm32/right:null -32880 68/push 0/imm32/right:null -32881 68/push 0/imm32/left:unused -32882 68/push 1/imm32/value:int -32883 68/push 1/imm32/is-atom?:true -32884 68/push 0x11/imm32/alloc-id:fake:payload -32885 89/<- %ecx 4/r32/esp -32886 $test-emit-subx-stmt-select-primitive-2:initialize-var: -32887 # var var-foo/ecx: (payload var) -32888 68/push 0/imm32/register -32889 68/push 0/imm32/register -32890 68/push 0/imm32/no-stack-offset -32891 68/push 1/imm32/block-depth -32892 51/push-ecx -32893 68/push 0x11/imm32/alloc-id:fake -32894 68/push 0/imm32/name -32895 68/push 0/imm32/name -32896 68/push 0x11/imm32/alloc-id:fake:payload -32897 89/<- %ecx 4/r32/esp -32898 $test-emit-subx-stmt-select-primitive-2:initialize-var-name: -32899 # var-foo->name = "foo" -32900 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -32901 (copy-array Heap "foo" %eax) -32902 $test-emit-subx-stmt-select-primitive-2:initialize-var-register: -32903 # var-foo->register = "eax" -32904 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -32905 (copy-array Heap "eax" %eax) -32906 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-var: -32907 # var operand/ebx: (payload stmt-var) -32908 68/push 0/imm32/is-deref:false -32909 68/push 0/imm32/next -32910 68/push 0/imm32/next -32911 51/push-ecx/var-foo -32912 68/push 0x11/imm32/alloc-id:fake -32913 68/push 0x11/imm32/alloc-id:fake:payload -32914 89/<- %ebx 4/r32/esp -32915 $test-emit-subx-stmt-select-primitive-2:initialize-stmt: -32916 # var stmt/esi: (addr statement) -32917 68/push 0/imm32/no-outputs -32918 68/push 0/imm32/no-outputs -32919 53/push-ebx/inouts -32920 68/push 0x11/imm32/alloc-id:fake -32921 68/push 0/imm32/operation -32922 68/push 0/imm32/operation -32923 68/push 1/imm32 -32924 89/<- %esi 4/r32/esp -32925 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-operation: -32926 # stmt->operation = "increment" -32927 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -32928 (copy-array Heap "increment" %eax) -32929 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var: -32930 # var formal-var/ebx: (payload var) -32931 68/push 0/imm32/register -32932 68/push 0/imm32/register -32933 68/push 0/imm32/no-stack-offset -32934 68/push 1/imm32/block-depth -32935 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id -32936 68/push 0x11/imm32/alloc-id:fake -32937 68/push 0/imm32/name -32938 68/push 0/imm32/name -32939 68/push 0x11/imm32/alloc-id:fake:payload -32940 89/<- %ebx 4/r32/esp -32941 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var-name: -32942 # formal-var->name = "dummy" -32943 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 -32944 (copy-array Heap "dummy" %eax) -32945 $test-emit-subx-stmt-select-primitive-2:initialize-formal-register: -32946 # formal-var->register = "*" -32947 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 -32948 (copy-array Heap "*" %eax) # Any-register -32949 $test-emit-subx-stmt-select-primitive-2:initialize-var-list: -32950 # var formal-outputs/ebx: (payload list stmt-var) -32951 68/push 0/imm32/next -32952 68/push 0/imm32/next -32953 53/push-ebx/formal-var -32954 68/push 0x11/imm32/alloc-id:fake -32955 68/push 0x11/imm32/alloc-id:fake:payload -32956 89/<- %ebx 4/r32/esp -32957 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2: -32958 # var primitive2/edi: (payload primitive) -32959 68/push 0/imm32/next -32960 68/push 0/imm32/next -32961 68/push 0/imm32/no-x32 -32962 68/push 0/imm32/no-xm32 -32963 68/push 0/imm32/no-disp32 -32964 68/push 0/imm32/no-imm8 -32965 68/push 0/imm32/no-imm32 -32966 68/push 0/imm32/no-r32 -32967 68/push 3/imm32/rm32-is-first-output -32968 68/push 0/imm32/subx-name -32969 68/push 0/imm32/subx-name -32970 53/push-ebx/outputs -32971 68/push 0x11/imm32/alloc-id:fake -32972 68/push 0/imm32/no-inouts -32973 68/push 0/imm32/no-inouts -32974 68/push 0/imm32/name -32975 68/push 0/imm32/name -32976 68/push 0x11/imm32/alloc-id:fake:payload -32977 89/<- %edi 4/r32/esp -32978 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-name: -32979 # primitives->name = "increment" -32980 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 -32981 (copy-array Heap "increment" %eax) -32982 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-subx-name: -32983 # primitives->subx-name = "ff 0/subop/increment" -32984 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 -32985 (copy-array Heap "ff 0/subop/increment" %eax) -32986 $test-emit-subx-stmt-select-primitive-2:initialize-primitive: -32987 # var primitives/ebx: (addr primitive) -32988 57/push-edi -32989 68/push 0x11/imm32/alloc-id:fake -32990 68/push 0/imm32/no-x32 -32991 68/push 0/imm32/no-xm32 -32992 68/push 0/imm32/no-disp32 -32993 68/push 0/imm32/no-imm8 -32994 68/push 0/imm32/no-imm32 -32995 68/push 0/imm32/no-r32 -32996 68/push 1/imm32/rm32-is-first-inout -32997 68/push 0/imm32/subx-name -32998 68/push 0/imm32/subx-name -32999 68/push 0/imm32/no-outputs -33000 68/push 0/imm32/no-outputs -33001 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration -33002 68/push 0x11/imm32/alloc-id:fake -33003 68/push 0/imm32/name -33004 68/push 0/imm32/name -33005 89/<- %ebx 4/r32/esp -33006 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-name: -33007 # primitives->name = "increment" -33008 (copy-array Heap "increment" %ebx) # Primitive-name -33009 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-subx-name: -33010 # primitives->subx-name = "ff 0/subop/increment" -33011 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name -33012 (copy-array Heap "ff 0/subop/increment" %eax) -33013 # convert -33014 c7 0/subop/copy *Curr-block-depth 0/imm32 -33015 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) -33016 (flush _test-output-buffered-file) -33017 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -33023 # check output -33024 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive-2") -33025 # . epilogue -33026 89/<- %esp 5/r32/ebp -33027 5d/pop-to-ebp -33028 c3/return -33029 -33030 test-increment-register: -33031 # Select the right register between overloads. -33032 # foo <- increment -33033 # => -33034 # 50/increment-eax -33035 # -33036 # There's a variable on the var stack as follows: -33037 # name: 'foo' -33038 # type: int -33039 # register: 'eax' -33040 # -33041 # Primitives are the global definitions. -33042 # -33043 # . prologue -33044 55/push-ebp -33045 89/<- %ebp 4/r32/esp -33046 # setup -33047 (clear-stream _test-output-stream) -33048 (clear-stream $_test-output-buffered-file->buffer) -33049 $test-increment-register:initialize-type: -33050 # var type/ecx: (payload type-tree) = int -33051 68/push 0/imm32/right:null -33052 68/push 0/imm32/right:null -33053 68/push 0/imm32/left:unused -33054 68/push 1/imm32/value:int -33055 68/push 1/imm32/is-atom?:true -33056 68/push 0x11/imm32/alloc-id:fake:payload -33057 89/<- %ecx 4/r32/esp -33058 $test-increment-register:initialize-var: -33059 # var var-foo/ecx: (payload var) -33060 68/push 0/imm32/register -33061 68/push 0/imm32/register -33062 68/push 0/imm32/no-stack-offset -33063 68/push 1/imm32/block-depth -33064 51/push-ecx -33065 68/push 0x11/imm32/alloc-id:fake -33066 68/push 0/imm32/name -33067 68/push 0/imm32/name -33068 68/push 0x11/imm32/alloc-id:fake:payload -33069 89/<- %ecx 4/r32/esp -33070 $test-increment-register:initialize-var-name: -33071 # var-foo->name = "foo" -33072 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -33073 (copy-array Heap "foo" %eax) -33074 $test-increment-register:initialize-var-register: -33075 # var-foo->register = "eax" -33076 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -33077 (copy-array Heap "eax" %eax) -33078 $test-increment-register:initialize-stmt-var: -33079 # var operand/ebx: (payload stmt-var) -33080 68/push 0/imm32/is-deref:false -33081 68/push 0/imm32/next -33082 68/push 0/imm32/next -33083 51/push-ecx/var-foo -33084 68/push 0x11/imm32/alloc-id:fake -33085 68/push 0x11/imm32/alloc-id:fake:payload -33086 89/<- %ebx 4/r32/esp -33087 $test-increment-register:initialize-stmt: -33088 # var stmt/esi: (addr statement) -33089 53/push-ebx/outputs -33090 68/push 0x11/imm32/alloc-id:fake -33091 68/push 0/imm32/no-inouts -33092 68/push 0/imm32/no-inouts -33093 68/push 0/imm32/operation -33094 68/push 0/imm32/operation -33095 68/push 1/imm32 -33096 89/<- %esi 4/r32/esp -33097 $test-increment-register:initialize-stmt-operation: -33098 # stmt->operation = "increment" -33099 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -33100 (copy-array Heap "increment" %eax) -33101 # convert -33102 c7 0/subop/copy *Curr-block-depth 0/imm32 -33103 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -33104 (flush _test-output-buffered-file) -33105 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -33111 # check output -33112 (check-next-stream-line-equal _test-output-stream "40/increment-eax" "F - test-increment-register") -33113 # . epilogue -33114 89/<- %esp 5/r32/ebp -33115 5d/pop-to-ebp -33116 c3/return -33117 -33118 test-add-reg-to-reg: -33119 # var1/reg <- add var2/reg -33120 # => -33121 # 01/add-to %var1 var2 -33122 # -33123 # . prologue -33124 55/push-ebp -33125 89/<- %ebp 4/r32/esp -33126 # setup -33127 (clear-stream _test-output-stream) -33128 (clear-stream $_test-output-buffered-file->buffer) -33129 $test-add-reg-to-reg:initialize-type: -33130 # var type/ecx: (payload type-tree) = int -33131 68/push 0/imm32/right:null -33132 68/push 0/imm32/right:null -33133 68/push 0/imm32/left:unused -33134 68/push 1/imm32/value:int -33135 68/push 1/imm32/is-atom?:true -33136 68/push 0x11/imm32/alloc-id:fake:payload -33137 89/<- %ecx 4/r32/esp -33138 $test-add-reg-to-reg:initialize-var1: -33139 # var var1/ecx: (payload var) -33140 68/push 0/imm32/register -33141 68/push 0/imm32/register -33142 68/push 0/imm32/no-stack-offset -33143 68/push 1/imm32/block-depth -33144 51/push-ecx -33145 68/push 0x11/imm32/alloc-id:fake -33146 68/push 0/imm32/name -33147 68/push 0/imm32/name -33148 68/push 0x11/imm32/alloc-id:fake:payload -33149 89/<- %ecx 4/r32/esp -33150 $test-add-reg-to-reg:initialize-var1-name: -33151 # var1->name = "var1" -33152 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -33153 (copy-array Heap "var1" %eax) -33154 $test-add-reg-to-reg:initialize-var1-register: -33155 # var1->register = "eax" -33156 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -33157 (copy-array Heap "eax" %eax) -33158 $test-add-reg-to-reg:initialize-var2: -33159 # var var2/edx: (payload var) -33160 68/push 0/imm32/register -33161 68/push 0/imm32/register -33162 68/push 0/imm32/no-stack-offset -33163 68/push 1/imm32/block-depth -33164 ff 6/subop/push *(ecx+0x10) -33165 68/push 0x11/imm32/alloc-id:fake -33166 68/push 0/imm32/name -33167 68/push 0/imm32/name -33168 68/push 0x11/imm32/alloc-id:fake:payload -33169 89/<- %edx 4/r32/esp -33170 $test-add-reg-to-reg:initialize-var2-name: -33171 # var2->name = "var2" -33172 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -33173 (copy-array Heap "var2" %eax) -33174 $test-add-reg-to-reg:initialize-var2-register: -33175 # var2->register = "ecx" -33176 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -33177 (copy-array Heap "ecx" %eax) -33178 $test-add-reg-to-reg:initialize-inouts: -33179 # var inouts/esi: (payload stmt-var) = [var2] -33180 68/push 0/imm32/is-deref:false -33181 68/push 0/imm32/next -33182 68/push 0/imm32/next -33183 52/push-edx/var2 -33184 68/push 0x11/imm32/alloc-id:fake -33185 68/push 0x11/imm32/alloc-id:fake:payload -33186 89/<- %esi 4/r32/esp -33187 $test-add-reg-to-reg:initialize-outputs: -33188 # var outputs/edi: (payload stmt-var) = [var1] -33189 68/push 0/imm32/is-deref:false -33190 68/push 0/imm32/next -33191 68/push 0/imm32/next -33192 51/push-ecx/var1 -33193 68/push 0x11/imm32/alloc-id:fake -33194 68/push 0x11/imm32/alloc-id:fake:payload -33195 89/<- %edi 4/r32/esp -33196 $test-add-reg-to-reg:initialize-stmt: -33197 # var stmt/esi: (addr statement) -33198 68/push 0/imm32/next -33199 68/push 0/imm32/next -33200 57/push-edi/outputs -33201 68/push 0x11/imm32/alloc-id:fake -33202 56/push-esi/inouts -33203 68/push 0x11/imm32/alloc-id:fake -33204 68/push 0/imm32/operation -33205 68/push 0/imm32/operation -33206 68/push 1/imm32/tag:stmt1 -33207 89/<- %esi 4/r32/esp -33208 $test-add-reg-to-reg:initialize-stmt-operation: -33209 # stmt->operation = "add" -33210 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -33211 (copy-array Heap "add" %eax) -33212 # convert -33213 c7 0/subop/copy *Curr-block-depth 0/imm32 -33214 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -33215 (flush _test-output-buffered-file) -33216 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -33222 # check output -33223 (check-next-stream-line-equal _test-output-stream "01/add-to %eax 0x00000001/r32" "F - test-add-reg-to-reg") -33224 # . epilogue -33225 89/<- %esp 5/r32/ebp -33226 5d/pop-to-ebp -33227 c3/return -33228 -33229 test-add-reg-to-mem: -33230 # add-to var1 var2/reg -33231 # => -33232 # 01/add-to *(ebp+__) var2 -33233 # -33234 # . prologue -33235 55/push-ebp -33236 89/<- %ebp 4/r32/esp -33237 # setup -33238 (clear-stream _test-output-stream) -33239 (clear-stream $_test-output-buffered-file->buffer) -33240 $test-add-reg-to-mem:initialize-type: -33241 # var type/ecx: (payload type-tree) = int -33242 68/push 0/imm32/right:null -33243 68/push 0/imm32/right:null -33244 68/push 0/imm32/left:unused -33245 68/push 1/imm32/value:int -33246 68/push 1/imm32/is-atom?:true -33247 68/push 0x11/imm32/alloc-id:fake:payload -33248 89/<- %ecx 4/r32/esp -33249 $test-add-reg-to-mem:initialize-var1: -33250 # var var1/ecx: (payload var) -33251 68/push 0/imm32/register -33252 68/push 0/imm32/register -33253 68/push 8/imm32/stack-offset -33254 68/push 1/imm32/block-depth -33255 51/push-ecx -33256 68/push 0x11/imm32/alloc-id:fake -33257 68/push 0/imm32/name -33258 68/push 0/imm32/name -33259 68/push 0x11/imm32/alloc-id:fake:payload -33260 89/<- %ecx 4/r32/esp -33261 $test-add-reg-to-mem:initialize-var1-name: -33262 # var1->name = "var1" -33263 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -33264 (copy-array Heap "var1" %eax) -33265 $test-add-reg-to-mem:initialize-var2: -33266 # var var2/edx: (payload var) -33267 68/push 0/imm32/register -33268 68/push 0/imm32/register -33269 68/push 0/imm32/no-stack-offset -33270 68/push 1/imm32/block-depth -33271 ff 6/subop/push *(ecx+0x10) -33272 68/push 0x11/imm32/alloc-id:fake -33273 68/push 0/imm32/name -33274 68/push 0/imm32/name -33275 68/push 0x11/imm32/alloc-id:fake:payload -33276 89/<- %edx 4/r32/esp -33277 $test-add-reg-to-mem:initialize-var2-name: -33278 # var2->name = "var2" -33279 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -33280 (copy-array Heap "var2" %eax) -33281 $test-add-reg-to-mem:initialize-var2-register: -33282 # var2->register = "ecx" -33283 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -33284 (copy-array Heap "ecx" %eax) -33285 $test-add-reg-to-mem:initialize-inouts: -33286 # var inouts/esi: (payload stmt-var) = [var2] -33287 68/push 0/imm32/is-deref:false -33288 68/push 0/imm32/next -33289 68/push 0/imm32/next -33290 52/push-edx/var2 -33291 68/push 0x11/imm32/alloc-id:fake -33292 68/push 0x11/imm32/alloc-id:fake:payload -33293 89/<- %esi 4/r32/esp -33294 # inouts = [var1, var2] -33295 68/push 0/imm32/is-deref:false -33296 56/push-esi/next -33297 68/push 0x11/imm32/alloc-id:fake -33298 51/push-ecx/var1 -33299 68/push 0x11/imm32/alloc-id:fake -33300 68/push 0x11/imm32/alloc-id:fake:payload -33301 89/<- %esi 4/r32/esp -33302 $test-add-reg-to-mem:initialize-stmt: -33303 # var stmt/esi: (addr statement) -33304 68/push 0/imm32/next -33305 68/push 0/imm32/next -33306 68/push 0/imm32/outputs -33307 68/push 0/imm32/outputs -33308 56/push-esi/inouts -33309 68/push 0x11/imm32/alloc-id:fake -33310 68/push 0/imm32/operation -33311 68/push 0/imm32/operation -33312 68/push 1/imm32/tag:stmt1 -33313 89/<- %esi 4/r32/esp -33314 $test-add-reg-to-mem:initialize-stmt-operation: -33315 # stmt->operation = "add-to" -33316 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -33317 (copy-array Heap "add-to" %eax) -33318 # convert -33319 c7 0/subop/copy *Curr-block-depth 0/imm32 -33320 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -33321 (flush _test-output-buffered-file) -33322 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -33328 # check output -33329 (check-next-stream-line-equal _test-output-stream "01/add-to *(ebp+0x00000008) 0x00000001/r32" "F - test-add-reg-to-mem") -33330 # . epilogue -33331 89/<- %esp 5/r32/ebp -33332 5d/pop-to-ebp -33333 c3/return -33334 -33335 test-add-mem-to-reg: -33336 # var1/reg <- add var2 -33337 # => -33338 # 03/add *(ebp+__) var1 -33339 # -33340 # . prologue -33341 55/push-ebp -33342 89/<- %ebp 4/r32/esp -33343 # setup -33344 (clear-stream _test-output-stream) -33345 (clear-stream $_test-output-buffered-file->buffer) -33346 $test-add-mem-to-reg:initialize-type: -33347 # var type/ecx: (payload type-tree) = int -33348 68/push 0/imm32/right:null -33349 68/push 0/imm32/right:null -33350 68/push 0/imm32/left:unused -33351 68/push 1/imm32/value:int -33352 68/push 1/imm32/is-atom?:true -33353 68/push 0x11/imm32/alloc-id:fake:payload -33354 89/<- %ecx 4/r32/esp -33355 $test-add-mem-to-reg:initialize-var: -33356 # var var1/ecx: (payload var) -33357 68/push 0/imm32/register -33358 68/push 0/imm32/register -33359 68/push 0/imm32/no-stack-offset -33360 68/push 1/imm32/block-depth -33361 51/push-ecx -33362 68/push 0x11/imm32/alloc-id:fake -33363 68/push 0/imm32/name -33364 68/push 0/imm32/name -33365 68/push 0x11/imm32/alloc-id:fake:payload -33366 89/<- %ecx 4/r32/esp -33367 $test-add-mem-to-reg:initialize-var-name: -33368 # var1->name = "foo" -33369 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -33370 (copy-array Heap "var1" %eax) -33371 $test-add-mem-to-reg:initialize-var-register: -33372 # var1->register = "eax" -33373 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -33374 (copy-array Heap "eax" %eax) -33375 $test-add-mem-to-reg:initialize-var2: -33376 # var var2/edx: (payload var) -33377 68/push 0/imm32/register -33378 68/push 0/imm32/register -33379 68/push 8/imm32/stack-offset -33380 68/push 1/imm32/block-depth -33381 ff 6/subop/push *(ecx+0x10) -33382 68/push 0x11/imm32/alloc-id:fake -33383 68/push 0/imm32/name -33384 68/push 0/imm32/name -33385 68/push 0x11/imm32/alloc-id:fake:payload -33386 89/<- %edx 4/r32/esp -33387 $test-add-mem-to-reg:initialize-var2-name: -33388 # var2->name = "var2" -33389 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -33390 (copy-array Heap "var2" %eax) -33391 $test-add-mem-to-reg:initialize-inouts: -33392 # var inouts/esi: (payload stmt-var) = [var2] -33393 68/push 0/imm32/is-deref:false -33394 68/push 0/imm32/next -33395 68/push 0/imm32/next -33396 52/push-edx/var2 -33397 68/push 0x11/imm32/alloc-id:fake -33398 68/push 0x11/imm32/alloc-id:fake:payload -33399 89/<- %esi 4/r32/esp -33400 $test-add-mem-to-reg:initialize-outputs: -33401 # var outputs/edi: (payload stmt-var) = [var1] -33402 68/push 0/imm32/is-deref:false -33403 68/push 0/imm32/next -33404 68/push 0/imm32/next -33405 51/push-ecx/var1 -33406 68/push 0x11/imm32/alloc-id:fake -33407 68/push 0x11/imm32/alloc-id:fake:payload -33408 89/<- %edi 4/r32/esp -33409 $test-add-mem-to-reg:initialize-stmt: -33410 # var stmt/esi: (addr statement) -33411 68/push 0/imm32/next -33412 68/push 0/imm32/next -33413 57/push-edi/outputs -33414 68/push 0x11/imm32/alloc-id:fake -33415 56/push-esi/inouts -33416 68/push 0x11/imm32/alloc-id:fake -33417 68/push 0/imm32/operation -33418 68/push 0/imm32/operation -33419 68/push 1/imm32/tag:stmt1 -33420 89/<- %esi 4/r32/esp -33421 $test-add-mem-to-reg:initialize-stmt-operation: -33422 # stmt->operation = "add" -33423 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -33424 (copy-array Heap "add" %eax) -33425 # convert -33426 c7 0/subop/copy *Curr-block-depth 0/imm32 -33427 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -33428 (flush _test-output-buffered-file) -33429 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -33435 # check output -33436 (check-next-stream-line-equal _test-output-stream "03/add *(ebp+0x00000008) 0x00000000/r32" "F - test-add-mem-to-reg") +32674 emit-subx-call-operand: # out: (addr buffered-file), s: (addr stmt-var) +32675 # shares code with emit-subx-var-as-rm32 +32676 # . prologue +32677 55/push-ebp +32678 89/<- %ebp 4/r32/esp +32679 # . save registers +32680 50/push-eax +32681 51/push-ecx +32682 56/push-esi +32683 # ecx = s +32684 8b/-> *(ebp+0xc) 1/r32/ecx +32685 # var operand/esi: (addr var) = lookup(s->value) +32686 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +32687 89/<- %esi 0/r32/eax +32688 # if (operand->register && !s->is-deref?) emit "%__" +32689 { +32690 $emit-subx-call-operand:check-for-register-direct: +32691 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +32692 74/jump-if-= break/disp8 +32693 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +32694 75/jump-if-!= break/disp8 +32695 $emit-subx-call-operand:register-direct: +32696 (write-buffered *(ebp+8) " %") +32697 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +32698 (write-buffered *(ebp+8) %eax) +32699 e9/jump $emit-subx-call-operand:end/disp32 +32700 } +32701 # else if (operand->register && s->is-deref?) emit "*__" +32702 { +32703 $emit-subx-call-operand:check-for-register-indirect: +32704 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +32705 74/jump-if-= break/disp8 +32706 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +32707 74/jump-if-= break/disp8 +32708 $emit-subx-call-operand:register-indirect: +32709 (emit-subx-call-operand-register-indirect *(ebp+8) %esi) +32710 e9/jump $emit-subx-call-operand:end/disp32 +32711 } +32712 # else if (operand->stack-offset) emit "*(ebp+__)" +32713 { +32714 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset +32715 74/jump-if-= break/disp8 +32716 $emit-subx-call-operand:stack: +32717 (emit-subx-call-operand-stack *(ebp+8) %esi) +32718 e9/jump $emit-subx-call-operand:end/disp32 +32719 } +32720 # else if (operand->type == literal) emit "__" +32721 { +32722 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax +32723 81 7/subop/compare *(eax+4) 0/imm32 # Type-tree-value +32724 75/jump-if-!= break/disp8 +32725 $emit-subx-call-operand:literal: +32726 (write-buffered *(ebp+8) Space) +32727 (lookup *esi *(esi+4)) # Var-name Var-name => eax +32728 (write-buffered *(ebp+8) %eax) +32729 e9/jump $emit-subx-call-operand:end/disp32 +32730 } +32731 # else if (operand->type == literal-string) emit "__" +32732 { +32733 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax +32734 81 7/subop/compare *(eax+4) 0x10/imm32 # Type-tree-value +32735 75/jump-if-!= break/disp8 +32736 $emit-subx-call-operand:literal-string: +32737 (write-buffered *(ebp+8) Space) +32738 (lookup *esi *(esi+4)) # Var-name Var-name => eax +32739 (write-buffered *(ebp+8) %eax) +32740 } +32741 $emit-subx-call-operand:end: +32742 # . restore registers +32743 5e/pop-to-esi +32744 59/pop-to-ecx +32745 58/pop-to-eax +32746 # . epilogue +32747 89/<- %esp 5/r32/ebp +32748 5d/pop-to-ebp +32749 c3/return +32750 +32751 emit-subx-call-operand-register-indirect: # out: (addr buffered-file), v: (addr var) +32752 # . prologue +32753 55/push-ebp +32754 89/<- %ebp 4/r32/esp +32755 # . save registers +32756 50/push-eax +32757 51/push-ecx +32758 56/push-esi +32759 # esi = v +32760 8b/-> *(ebp+0xc) 6/r32/esi +32761 # var size/ecx: int = size-of-deref(v) +32762 (size-of-deref %esi) # => eax +32763 89/<- %ecx 0/r32/eax +32764 # var reg-name/esi: (addr array byte) = lookup(v->register) +32765 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +32766 89/<- %esi 0/r32/eax +32767 # TODO: assert size is a multiple of 4 +32768 # var i/eax: int = 0 +32769 b8/copy-to-eax 0/imm32 +32770 { +32771 $emit-subx-call-operand-register-indirect:loop: +32772 # if (i >= size) break +32773 39/compare %eax 1/r32/ecx +32774 7d/jump-if->= break/disp8 +32775 # emit " *(" v->register "+" i ")" +32776 (write-buffered *(ebp+8) " *(") +32777 (write-buffered *(ebp+8) %esi) +32778 (write-buffered *(ebp+8) "+") +32779 (write-int32-hex-buffered *(ebp+8) %eax) +32780 (write-buffered *(ebp+8) ")") +32781 # i += 4 +32782 05/add-to-eax 4/imm32 +32783 # +32784 eb/jump loop/disp8 +32785 } +32786 $emit-subx-call-operand-register-indirect:end: +32787 # . restore registers +32788 5e/pop-to-esi +32789 59/pop-to-ecx +32790 58/pop-to-eax +32791 # . epilogue +32792 89/<- %esp 5/r32/ebp +32793 5d/pop-to-ebp +32794 c3/return +32795 +32796 emit-subx-call-operand-stack: # out: (addr buffered-file), v: (addr var) +32797 # . prologue +32798 55/push-ebp +32799 89/<- %ebp 4/r32/esp +32800 # . save registers +32801 50/push-eax +32802 51/push-ecx +32803 56/push-esi +32804 # esi = v +32805 8b/-> *(ebp+0xc) 6/r32/esi +32806 # var curr/ecx: int = v->offset +32807 8b/-> *(esi+0x14) 1/r32/ecx # Var-offset +32808 # var max/eax: int = v->offset + size-of(v) +32809 (size-of %esi) # => eax +32810 # TODO: assert size is a multiple of 4 +32811 01/add-to %eax 1/r32/ecx +32812 { +32813 $emit-subx-call-operand-stack:loop: +32814 # if (curr >= max) break +32815 39/compare %ecx 0/r32/eax +32816 7d/jump-if->= break/disp8 +32817 # emit " *(ebp+" curr ")" +32818 (write-buffered *(ebp+8) " *(ebp+") +32819 (write-int32-hex-buffered *(ebp+8) %ecx) +32820 (write-buffered *(ebp+8) ")") +32821 # i += 4 +32822 81 0/subop/add %ecx 4/imm32 +32823 # +32824 eb/jump loop/disp8 +32825 } +32826 $emit-subx-call-operand-stack:end: +32827 # . restore registers +32828 5e/pop-to-esi +32829 59/pop-to-ecx +32830 58/pop-to-eax +32831 # . epilogue +32832 89/<- %esp 5/r32/ebp +32833 5d/pop-to-ebp +32834 c3/return +32835 +32836 emit-subx-var-as-rm32: # out: (addr buffered-file), s: (addr stmt-var) +32837 # . prologue +32838 55/push-ebp +32839 89/<- %ebp 4/r32/esp +32840 # . save registers +32841 50/push-eax +32842 51/push-ecx +32843 56/push-esi +32844 # ecx = s +32845 8b/-> *(ebp+0xc) 1/r32/ecx +32846 # var operand/esi: (addr var) = lookup(s->value) +32847 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +32848 89/<- %esi 0/r32/eax +32849 # if (operand->register && s->is-deref?) emit "*__" +32850 { +32851 $emit-subx-var-as-rm32:check-for-register-indirect: +32852 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +32853 74/jump-if-= break/disp8 +32854 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +32855 74/jump-if-= break/disp8 +32856 $emit-subx-var-as-rm32:register-indirect: +32857 (write-buffered *(ebp+8) " *") +32858 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +32859 (write-buffered *(ebp+8) %eax) +32860 e9/jump $emit-subx-var-as-rm32:end/disp32 +32861 } +32862 # if (operand->register && !s->is-deref?) emit "%__" +32863 { +32864 $emit-subx-var-as-rm32:check-for-register-direct: +32865 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +32866 74/jump-if-= break/disp8 +32867 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +32868 75/jump-if-!= break/disp8 +32869 $emit-subx-var-as-rm32:register-direct: +32870 (write-buffered *(ebp+8) " %") +32871 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +32872 (write-buffered *(ebp+8) %eax) +32873 e9/jump $emit-subx-var-as-rm32:end/disp32 +32874 } +32875 # else if (operand->stack-offset) emit "*(ebp+__)" +32876 { +32877 81 7/subop/compare *(esi+0x14) 0/imm32 # Var-offset +32878 74/jump-if-= break/disp8 +32879 $emit-subx-var-as-rm32:stack: +32880 (write-buffered *(ebp+8) Space) +32881 (write-buffered *(ebp+8) "*(ebp+") +32882 (write-int32-hex-buffered *(ebp+8) *(esi+0x14)) # Var-offset +32883 (write-buffered *(ebp+8) ")") +32884 } +32885 $emit-subx-var-as-rm32:end: +32886 # . restore registers +32887 5e/pop-to-esi +32888 59/pop-to-ecx +32889 58/pop-to-eax +32890 # . epilogue +32891 89/<- %esp 5/r32/ebp +32892 5d/pop-to-ebp +32893 c3/return +32894 +32895 find-matching-primitive: # primitives: (addr primitive), stmt: (addr stmt) -> result/eax: (addr primitive) +32896 # . prologue +32897 55/push-ebp +32898 89/<- %ebp 4/r32/esp +32899 # . save registers +32900 51/push-ecx +32901 # var curr/ecx: (addr primitive) = primitives +32902 8b/-> *(ebp+8) 1/r32/ecx +32903 { +32904 $find-matching-primitive:loop: +32905 # if (curr == null) break +32906 81 7/subop/compare %ecx 0/imm32 +32907 74/jump-if-= break/disp8 +32908 # if match(curr, stmt) return curr +32909 { +32910 (mu-stmt-matches-primitive? *(ebp+0xc) %ecx) # => eax +32911 3d/compare-eax-and 0/imm32/false +32912 74/jump-if-= break/disp8 +32913 89/<- %eax 1/r32/ecx +32914 eb/jump $find-matching-primitive:end/disp8 +32915 } +32916 $find-matching-primitive:next-primitive: +32917 # curr = curr->next +32918 (lookup *(ecx+0x3c) *(ecx+0x40)) # Primitive-next Primitive-next => eax +32919 89/<- %ecx 0/r32/eax +32920 # +32921 e9/jump loop/disp32 +32922 } +32923 # return null +32924 b8/copy-to-eax 0/imm32 +32925 $find-matching-primitive:end: +32926 # . restore registers +32927 59/pop-to-ecx +32928 # . epilogue +32929 89/<- %esp 5/r32/ebp +32930 5d/pop-to-ebp +32931 c3/return +32932 +32933 mu-stmt-matches-primitive?: # stmt: (addr stmt), primitive: (addr primitive) -> result/eax: boolean +32934 # A mu stmt matches a primitive if the name matches, all the inout vars +32935 # match, and all the output vars match. +32936 # Vars match if types match and registers match. +32937 # In addition, a stmt output matches a primitive's output if types match +32938 # and the primitive has a wildcard register. +32939 # . prologue +32940 55/push-ebp +32941 89/<- %ebp 4/r32/esp +32942 # . save registers +32943 51/push-ecx +32944 52/push-edx +32945 53/push-ebx +32946 56/push-esi +32947 57/push-edi +32948 # ecx = stmt +32949 8b/-> *(ebp+8) 1/r32/ecx +32950 # edx = primitive +32951 8b/-> *(ebp+0xc) 2/r32/edx +32952 { +32953 $mu-stmt-matches-primitive?:check-name: +32954 # if (primitive->name != stmt->operation) return false +32955 # . var esi: (addr array byte) = lookup(stmt->operation) +32956 (lookup *(ecx+4) *(ecx+8)) # Stmt1-operation Stmt1-operation => eax +32957 89/<- %esi 0/r32/eax +32958 # . var edi: (addr array byte) = lookup(primitive->name) +32959 (lookup *edx *(edx+4)) # Primitive-name Primitive-name => eax +32960 #? (write-buffered Stderr %eax) +32961 #? (write-buffered Stderr Newline) +32962 #? (flush Stderr) +32963 89/<- %edi 0/r32/eax +32964 (string-equal? %esi %edi) # => eax +32965 3d/compare-eax-and 0/imm32/false +32966 75/jump-if-!= break/disp8 +32967 b8/copy-to-eax 0/imm32 +32968 e9/jump $mu-stmt-matches-primitive?:end/disp32 +32969 } +32970 # var curr/esi: (addr stmt-var) = lookup(stmt->inouts) +32971 (lookup *(ecx+0xc) *(ecx+0x10)) # Stmt1-inouts Stmt1-inouts => eax +32972 89/<- %esi 0/r32/eax +32973 # var curr2/edi: (addr list var) = lookup(primitive->inouts) +32974 (lookup *(edx+8) *(edx+0xc)) # Primitive-inouts Primitive-inouts => eax +32975 89/<- %edi 0/r32/eax +32976 { +32977 $mu-stmt-matches-primitive?:inouts-loop: +32978 # if (curr == 0 && curr2 == 0) move on to check outputs +32979 { +32980 $mu-stmt-matches-primitive?:check-both-inouts-null: +32981 81 7/subop/compare %esi 0/imm32 +32982 75/jump-if-!= break/disp8 +32983 $mu-stmt-matches-primitive?:stmt-inout-null: +32984 81 7/subop/compare %edi 0/imm32 +32985 0f 84/jump-if-= $mu-stmt-matches-primitive?:check-outputs/disp32 +32986 $mu-stmt-matches-primitive?:stmt-inout-null-and-prim-inout-not-null: +32987 # return false +32988 b8/copy-to-eax 0/imm32/false +32989 e9/jump $mu-stmt-matches-primitive?:end/disp32 +32990 } +32991 # if (curr2 == 0) return false +32992 { +32993 $mu-stmt-matches-primitive?:check-prim-inout-null: +32994 81 7/subop/compare %edi 0/imm32 +32995 75/jump-if-!= break/disp8 +32996 $mu-stmt-matches-primitive?:prim-inout-null: +32997 b8/copy-to-eax 0/imm32/false +32998 e9/jump $mu-stmt-matches-primitive?:end/disp32 +32999 } +33000 # if (curr != curr2) return false +33001 { +33002 $mu-stmt-matches-primitive?:check-inouts-match: +33003 (lookup *edi *(edi+4)) # List-value List-value => eax +33004 (operand-matches-primitive? %esi %eax) # => eax +33005 3d/compare-eax-and 0/imm32/false +33006 75/jump-if-!= break/disp8 +33007 $mu-stmt-matches-primitive?:inouts-match: +33008 b8/copy-to-eax 0/imm32/false +33009 e9/jump $mu-stmt-matches-primitive?:end/disp32 +33010 } +33011 $mu-stmt-matches-primitive?:next-inout: +33012 # curr = lookup(curr->next) +33013 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +33014 89/<- %esi 0/r32/eax +33015 # curr2 = lookup(curr2->next) +33016 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax +33017 89/<- %edi 0/r32/eax +33018 # +33019 e9/jump loop/disp32 +33020 } +33021 $mu-stmt-matches-primitive?:check-outputs: +33022 # var curr/esi: (addr stmt-var) = lookup(stmt->outputs) +33023 (lookup *(ecx+0x14) *(ecx+0x18)) # Stmt1-outputs Stmt1-outputs => eax +33024 89/<- %esi 0/r32/eax +33025 # var curr2/edi: (addr list var) = lookup(primitive->outputs) +33026 (lookup *(edx+0x10) *(edx+0x14)) # Primitive-outputs Primitive-outputs => eax +33027 89/<- %edi 0/r32/eax +33028 { +33029 $mu-stmt-matches-primitive?:outputs-loop: +33030 # if (curr == 0) return (curr2 == 0) +33031 { +33032 $mu-stmt-matches-primitive?:check-both-outputs-null: +33033 81 7/subop/compare %esi 0/imm32 +33034 75/jump-if-!= break/disp8 +33035 { +33036 $mu-stmt-matches-primitive?:stmt-output-null: +33037 81 7/subop/compare %edi 0/imm32 +33038 75/jump-if-!= break/disp8 +33039 $mu-stmt-matches-primitive?:both-outputs-null: +33040 # return true +33041 b8/copy-to-eax 1/imm32 +33042 e9/jump $mu-stmt-matches-primitive?:end/disp32 +33043 } +33044 $mu-stmt-matches-primitive?:stmt-output-null-and-prim-output-not-null: +33045 # return false +33046 b8/copy-to-eax 0/imm32 +33047 e9/jump $mu-stmt-matches-primitive?:end/disp32 +33048 } +33049 # if (curr2 == 0) return false +33050 { +33051 $mu-stmt-matches-primitive?:check-prim-output-null: +33052 81 7/subop/compare %edi 0/imm32 +33053 75/jump-if-!= break/disp8 +33054 $mu-stmt-matches-primitive?:prim-output-is-null: +33055 b8/copy-to-eax 0/imm32 +33056 e9/jump $mu-stmt-matches-primitive?:end/disp32 +33057 } +33058 # if (curr != curr2) return false +33059 { +33060 $mu-stmt-matches-primitive?:check-outputs-match: +33061 (lookup *edi *(edi+4)) # List-value List-value => eax +33062 (operand-matches-primitive? %esi %eax) # => eax +33063 3d/compare-eax-and 0/imm32/false +33064 75/jump-if-!= break/disp8 +33065 $mu-stmt-matches-primitive?:outputs-match: +33066 b8/copy-to-eax 0/imm32 +33067 e9/jump $mu-stmt-matches-primitive?:end/disp32 +33068 } +33069 $mu-stmt-matches-primitive?:next-output: +33070 # curr = lookup(curr->next) +33071 (lookup *(esi+8) *(esi+0xc)) # Stmt-var-next Stmt-var-next => eax +33072 89/<- %esi 0/r32/eax +33073 # curr2 = lookup(curr2->next) +33074 (lookup *(edi+8) *(edi+0xc)) # List-next List-next => eax +33075 89/<- %edi 0/r32/eax +33076 # +33077 e9/jump loop/disp32 +33078 } +33079 $mu-stmt-matches-primitive?:return-true: +33080 b8/copy-to-eax 1/imm32 +33081 $mu-stmt-matches-primitive?:end: +33082 # . restore registers +33083 5f/pop-to-edi +33084 5e/pop-to-esi +33085 5b/pop-to-ebx +33086 5a/pop-to-edx +33087 59/pop-to-ecx +33088 # . epilogue +33089 89/<- %esp 5/r32/ebp +33090 5d/pop-to-ebp +33091 c3/return +33092 +33093 operand-matches-primitive?: # s: (addr stmt-var), prim-var: (addr var) -> result/eax: boolean +33094 # . prologue +33095 55/push-ebp +33096 89/<- %ebp 4/r32/esp +33097 # . save registers +33098 51/push-ecx +33099 52/push-edx +33100 53/push-ebx +33101 56/push-esi +33102 57/push-edi +33103 # ecx = s +33104 8b/-> *(ebp+8) 1/r32/ecx +33105 # var var/esi: (addr var) = lookup(s->value) +33106 (lookup *ecx *(ecx+4)) # Stmt-var-value Stmt-var-value => eax +33107 89/<- %esi 0/r32/eax +33108 # edi = prim-var +33109 8b/-> *(ebp+0xc) 7/r32/edi +33110 $operand-matches-primitive?:check-type: +33111 # if !category-match?(var->type, prim-var->type) return false +33112 # . var vtype/ebx: (addr type-tree) = lookup(var->type) +33113 (lookup *(esi+8) *(esi+0xc)) # Var-type Var-type => eax +33114 89/<- %ebx 0/r32/eax +33115 # . if s is deref, vtype = vtype->right +33116 { +33117 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +33118 74/jump-if-= break/disp8 +33119 $operand-matches-primitive?:is-deref: +33120 # . var t/eax: (addr type) +33121 (lookup *(ebx+0xc) *(ebx+0x10)) # Type-tree-right Type-tree-right => eax +33122 # . if !t->is-atom? t = t->left +33123 81 7/subop/compare *eax 0/imm32/false +33124 { +33125 75/jump-if-!= break/disp8 +33126 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +33127 } +33128 # . +33129 89/<- %ebx 0/r32/eax +33130 } +33131 # . var ptype/eax: (addr type-tree) = lookup(prim-var->type) +33132 (lookup *(edi+8) *(edi+0xc)) # Var-type Var-type => eax +33133 (subx-type-category-match? %ebx %eax) # => eax +33134 3d/compare-eax-and 0/imm32/false +33135 0f 84/jump-if-= $operand-matches-primitive?:return-false/disp32 +33136 { +33137 $operand-matches-primitive?:check-register: +33138 # if prim-var is in memory and var is in register but dereference, match +33139 { +33140 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register +33141 0f 85/jump-if-!= break/disp32 +33142 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +33143 74/jump-if-= break/disp8 +33144 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +33145 74/jump-if-= break/disp8 +33146 $operand-matches-primitive?:var-deref-match: +33147 e9/jump $operand-matches-primitive?:return-true/disp32 +33148 } +33149 # if prim-var is in register and var is in register but dereference, no match +33150 { +33151 81 7/subop/compare *(edi+0x18) 0/imm32 # Var-register +33152 0f 84/jump-if-= break/disp32 +33153 81 7/subop/compare *(esi+0x18) 0/imm32 # Var-register +33154 0f 84/jump-if-= break/disp32 +33155 81 7/subop/compare *(ecx+0x10) 0/imm32/false # Stmt-var-is-deref +33156 74/jump-if-= break/disp8 +33157 $operand-matches-primitive?:var-deref-no-match: +33158 e9/jump $operand-matches-primitive?:return-false/disp32 +33159 } +33160 # return false if var->register doesn't match prim-var->register +33161 { +33162 # if register addresses are equal, it's a match +33163 # var vreg/ebx: (addr array byte) = lookup(var->register) +33164 (lookup *(esi+0x18) *(esi+0x1c)) # Var-register Var-register => eax +33165 89/<- %ebx 0/r32/eax +33166 # var preg/ecx: (addr array byte) = lookup(prim-var->register) +33167 (lookup *(edi+0x18) *(edi+0x1c)) # Var-register Var-register => eax +33168 89/<- %ecx 0/r32/eax +33169 # if (vreg == preg) break +33170 39/compare %ecx 3/r32/ebx +33171 74/jump-if-= break/disp8 +33172 $operand-matches-primitive?:var-register-no-match: +33173 # if either address is 0, return false +33174 81 7/subop/compare %ebx 0/imm32 +33175 74/jump-if-= $operand-matches-primitive?:return-false/disp8 +33176 81 7/subop/compare %ecx 0/imm32 +33177 74/jump-if-= $operand-matches-primitive?:return-false/disp8 +33178 # if prim-var->register is wildcard, it's a match +33179 (string-equal? %ecx "*") # Any-register => eax +33180 3d/compare-eax-and 0/imm32/false +33181 75/jump-if-!= break/disp8 +33182 $operand-matches-primitive?:wildcard-no-match: +33183 # if string contents aren't equal, return false +33184 (string-equal? %ecx %ebx) # => eax +33185 3d/compare-eax-and 0/imm32/false +33186 74/jump-if-= $operand-matches-primitive?:return-false/disp8 +33187 } +33188 } +33189 $operand-matches-primitive?:return-true: +33190 b8/copy-to-eax 1/imm32/true +33191 eb/jump $operand-matches-primitive?:end/disp8 +33192 $operand-matches-primitive?:return-false: +33193 b8/copy-to-eax 0/imm32/false +33194 $operand-matches-primitive?:end: +33195 # . restore registers +33196 5f/pop-to-edi +33197 5e/pop-to-esi +33198 5b/pop-to-ebx +33199 5a/pop-to-edx +33200 59/pop-to-ecx +33201 # . epilogue +33202 89/<- %esp 5/r32/ebp +33203 5d/pop-to-ebp +33204 c3/return +33205 +33206 find-matching-function: # functions: (addr function), stmt: (addr stmt) -> result/eax: (addr function) +33207 # . prologue +33208 55/push-ebp +33209 89/<- %ebp 4/r32/esp +33210 # . save registers +33211 51/push-ecx +33212 # var curr/ecx: (handle function) = functions +33213 8b/-> *(ebp+8) 1/r32/ecx +33214 { +33215 # if (curr == null) break +33216 81 7/subop/compare %ecx 0/imm32 +33217 74/jump-if-= break/disp8 +33218 #? (write-buffered Stderr "iter\n") +33219 #? (flush Stderr) +33220 # if match(stmt, curr) return curr +33221 { +33222 (mu-stmt-matches-function? *(ebp+0xc) %ecx) # => eax +33223 3d/compare-eax-and 0/imm32/false +33224 74/jump-if-= break/disp8 +33225 89/<- %eax 1/r32/ecx +33226 eb/jump $find-matching-function:end/disp8 +33227 } +33228 # curr = curr->next +33229 (lookup *(ecx+0x20) *(ecx+0x24)) # Function-next Function-next => eax +33230 89/<- %ecx 0/r32/eax +33231 # +33232 eb/jump loop/disp8 +33233 } +33234 # return null +33235 b8/copy-to-eax 0/imm32 +33236 $find-matching-function:end: +33237 # . restore registers +33238 59/pop-to-ecx +33239 # . epilogue +33240 89/<- %esp 5/r32/ebp +33241 5d/pop-to-ebp +33242 c3/return +33243 +33244 # Just compare names; user-defined functions don't support overloading yet. +33245 mu-stmt-matches-function?: # stmt: (addr stmt1), function: (addr function) -> result/eax: boolean +33246 # . prologue +33247 55/push-ebp +33248 89/<- %ebp 4/r32/esp +33249 # . save registers +33250 51/push-ecx +33251 # return function->name == stmt->operation +33252 # ecx = lookup(stmt->operation) +33253 8b/-> *(ebp+8) 0/r32/eax +33254 (lookup *(eax+4) *(eax+8)) # Stmt1-operation Stmt1-operation => eax +33255 89/<- %ecx 0/r32/eax +33256 # eax = lookup(function->name) +33257 8b/-> *(ebp+0xc) 0/r32/eax +33258 (lookup *eax *(eax+4)) # Function-name Function-name => eax +33259 (string-equal? %eax %ecx) # => eax +33260 $mu-stmt-matches-function?:end: +33261 # . restore registers +33262 59/pop-to-ecx +33263 # . epilogue +33264 89/<- %esp 5/r32/ebp +33265 5d/pop-to-ebp +33266 c3/return +33267 +33268 # Type-checking happens elsewhere. This method is for selecting between +33269 # primitives. +33270 subx-type-category-match?: # a: (addr type-tree), b: (addr type-tree) -> result/eax: boolean +33271 # . prologue +33272 55/push-ebp +33273 89/<- %ebp 4/r32/esp +33274 # . save registers +33275 51/push-ecx +33276 # var cata/ecx: int = type-category(a) +33277 (type-category *(ebp+8)) # => eax +33278 89/<- %ecx 0/r32/eax +33279 # var catb/eax: int = type-category(b) +33280 (type-category *(ebp+0xc)) # => eax +33281 # return cata == catb +33282 39/compare %eax 1/r32/ecx +33283 0f 94/set-byte-if-= %al +33284 81 4/subop/and %eax 0xff/imm32 +33285 $subx-type-category-match?:end: +33286 # . restore registers +33287 59/pop-to-ecx +33288 # . epilogue +33289 89/<- %esp 5/r32/ebp +33290 5d/pop-to-ebp +33291 c3/return +33292 +33293 type-category: # a: (addr type-tree) -> result/eax: int +33294 # . prologue +33295 55/push-ebp +33296 89/<- %ebp 4/r32/esp +33297 # . save registers +33298 51/push-ecx +33299 # var lit?/ecx: boolean = is-literal-type?(a) +33300 (is-simple-mu-type? *(ebp+8) 0) # literal => eax +33301 89/<- %ecx 0/r32/eax +33302 # var float?/eax: int = is-float?(a) +33303 (is-simple-mu-type? *(ebp+8) 0xf) # => eax +33304 # set bits for lit? and float? +33305 c1/shift 4/subop/left %ecx 1/imm8 +33306 09/or %eax 1/r32/ecx +33307 $type-category:end: +33308 # . restore registers +33309 59/pop-to-ecx +33310 # . epilogue +33311 89/<- %esp 5/r32/ebp +33312 5d/pop-to-ebp +33313 c3/return +33314 +33315 is-simple-mu-type?: # a: (addr type-tree), n: type-id -> result/eax: boolean +33316 # . prologue +33317 55/push-ebp +33318 89/<- %ebp 4/r32/esp +33319 # . save registers +33320 51/push-ecx +33321 # ecx = n +33322 8b/-> *(ebp+0xc) 1/r32/ecx +33323 # return (a->value == n) +33324 8b/-> *(ebp+8) 0/r32/eax +33325 39/compare *(eax+4) 1/r32/ecx # Type-tree-value +33326 0f 94/set-byte-if-= %al +33327 81 4/subop/and %eax 0xff/imm32 +33328 $is-simple-mu-type?:end: +33329 # . restore registers +33330 59/pop-to-ecx +33331 # . epilogue +33332 89/<- %esp 5/r32/ebp +33333 5d/pop-to-ebp +33334 c3/return +33335 +33336 is-mu-addr-type?: # a: (addr type-tree) -> result/eax: boolean +33337 # . prologue +33338 55/push-ebp +33339 89/<- %ebp 4/r32/esp +33340 # eax = a +33341 8b/-> *(ebp+8) 0/r32/eax +33342 # if (!a->is-atom?) a = a->left +33343 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +33344 { +33345 75/jump-if-!= break/disp8 +33346 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +33347 } +33348 # return (a->value == addr) +33349 81 7/subop/compare *(eax+4) 2/imm32/addr # Type-tree-value +33350 0f 94/set-byte-if-= %al +33351 81 4/subop/and %eax 0xff/imm32 +33352 $is-mu-addr-type?:end: +33353 # . epilogue +33354 89/<- %esp 5/r32/ebp +33355 5d/pop-to-ebp +33356 c3/return +33357 +33358 is-mu-array-type?: # a: (addr type-tree) -> result/eax: boolean +33359 # . prologue +33360 55/push-ebp +33361 89/<- %ebp 4/r32/esp +33362 # eax = a +33363 8b/-> *(ebp+8) 0/r32/eax +33364 # if (!a->is-atom?) a = a->left +33365 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +33366 { +33367 75/jump-if-!= break/disp8 +33368 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +33369 } +33370 # return (a->value == array) +33371 81 7/subop/compare *(eax+4) 3/imm32/array # Type-tree-value +33372 0f 94/set-byte-if-= %al +33373 81 4/subop/and %eax 0xff/imm32 +33374 $is-mu-array-type?:end: +33375 # . epilogue +33376 89/<- %esp 5/r32/ebp +33377 5d/pop-to-ebp +33378 c3/return +33379 +33380 is-mu-string-type?: # a: (addr type-tree) -> result/eax: boolean +33381 # . prologue +33382 55/push-ebp +33383 89/<- %ebp 4/r32/esp +33384 # . save registers +33385 56/push-esi +33386 # esi = a +33387 8b/-> *(ebp+8) 6/r32/esi +33388 # if (a->is-atom?) return false +33389 81 7/subop/compare *esi 0/imm32/false # Type-tree-is-atom +33390 0f 85/jump-if-!= $is-mu-string-type?:return-false/disp32 +33391 # if a is not an addr, return false +33392 (is-mu-addr-type? %esi) # => eax +33393 3d/compare-eax-with 0/imm32/false +33394 0f 84/jump-if-= $is-mu-string-type?:end/disp32 # eax changes var +33395 # if a is not an array, return false +33396 (lookup *(esi+0xc) *(esi+0x10)) # Type-tree-right Type-tree-right => eax +33397 (is-mu-array-type? %eax) # => eax +33398 3d/compare-eax-with 0/imm32/false +33399 74/jump-if-= $is-mu-string-type?:end/disp8 # eax changes var +33400 # var p/eax: (addr type-tree) = payload of a +33401 (lookup *(esi+0xc) *(esi+0x10)) # Type-tree-right Type-tree-right => eax +33402 (lookup *(eax+0xc) *(eax+0x10)) # Type-tree-right Type-tree-right => eax +33403 # if p is an atom, return false +33404 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +33405 75/jump-if-!= $is-mu-string-type?:return-false/disp8 +33406 # return (p == byte) +33407 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +33408 (is-simple-mu-type? %eax 8) # byte => eax +33409 eb/jump $is-mu-string-type?:end/disp8 +33410 $is-mu-string-type?:return-false: +33411 b8/copy-to-eax 0/imm32/false +33412 $is-mu-string-type?:end: +33413 # . restore registers +33414 5e/pop-to-esi +33415 # . epilogue +33416 89/<- %esp 5/r32/ebp +33417 5d/pop-to-ebp +33418 c3/return +33419 +33420 is-mu-stream-type?: # a: (addr type-tree) -> result/eax: boolean +33421 # . prologue +33422 55/push-ebp +33423 89/<- %ebp 4/r32/esp +33424 # eax = a +33425 8b/-> *(ebp+8) 0/r32/eax +33426 # if (!a->is-atom?) a = a->left +33427 81 7/subop/compare *eax 0/imm32/false # Type-tree-is-atom +33428 { +33429 75/jump-if-!= break/disp8 +33430 (lookup *(eax+4) *(eax+8)) # Type-tree-left Type-tree-left => eax +33431 } +33432 # return (a->value == stream) +33433 81 7/subop/compare *(eax+4) 0xb/imm32/stream # Type-tree-value +33434 0f 94/set-byte-if-= %al +33435 81 4/subop/and %eax 0xff/imm32 +33436 $is-mu-stream-type?:end: 33437 # . epilogue 33438 89/<- %esp 5/r32/ebp 33439 5d/pop-to-ebp 33440 c3/return 33441 -33442 test-add-literal-to-eax: -33443 # var1/eax <- add 0x34 -33444 # => -33445 # 05/add-to-eax 0x34/imm32 -33446 # -33447 # . prologue -33448 55/push-ebp -33449 89/<- %ebp 4/r32/esp -33450 # setup -33451 (clear-stream _test-output-stream) -33452 (clear-stream $_test-output-buffered-file->buffer) -33453 $test-add-literal-to-eax:initialize-var-type: -33454 # var type/ecx: (payload type-tree) = int -33455 68/push 0/imm32/right:null -33456 68/push 0/imm32/right:null -33457 68/push 0/imm32/left:unused -33458 68/push 1/imm32/value:int -33459 68/push 1/imm32/is-atom?:true -33460 68/push 0x11/imm32/alloc-id:fake:payload -33461 89/<- %ecx 4/r32/esp -33462 $test-add-literal-to-eax:initialize-var: -33463 # var v/ecx: (payload var) -33464 68/push 0/imm32/register -33465 68/push 0/imm32/register -33466 68/push 0/imm32/no-stack-offset -33467 68/push 1/imm32/block-depth -33468 51/push-ecx -33469 68/push 0x11/imm32/alloc-id:fake -33470 68/push 0/imm32/name -33471 68/push 0/imm32/name +33442 test-emit-subx-stmt-primitive: +33443 # Primitive operation on a variable on the stack. +33444 # increment foo +33445 # => +33446 # ff 0/subop/increment *(ebp-8) +33447 # +33448 # There's a variable on the var stack as follows: +33449 # name: 'foo' +33450 # type: int +33451 # stack-offset: -8 +33452 # +33453 # There's a primitive with this info: +33454 # name: 'increment' +33455 # inouts: int/mem +33456 # value: 'ff 0/subop/increment' +33457 # +33458 # . prologue +33459 55/push-ebp +33460 89/<- %ebp 4/r32/esp +33461 # setup +33462 (clear-stream _test-output-stream) +33463 (clear-stream $_test-output-buffered-file->buffer) +33464 # simulate allocated payloads starting with an initial fake alloc-id (0x11) +33465 $test-emit-subx-stmt-primitive:initialize-type: +33466 # var type/ecx: (payload type-tree) = int +33467 68/push 0/imm32/right:null +33468 68/push 0/imm32/right:null +33469 68/push 0/imm32/left:unused +33470 68/push 1/imm32/value:int +33471 68/push 1/imm32/is-atom?:true 33472 68/push 0x11/imm32/alloc-id:fake:payload 33473 89/<- %ecx 4/r32/esp -33474 $test-add-literal-to-eax:initialize-var-name: -33475 # v->name = "v" -33476 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -33477 (copy-array Heap "v" %eax) -33478 $test-add-literal-to-eax:initialize-var-register: -33479 # v->register = "eax" -33480 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -33481 (copy-array Heap "eax" %eax) -33482 $test-add-literal-to-eax:initialize-literal-type: -33483 # var type/edx: (payload type-tree) = literal -33484 68/push 0/imm32/right:null -33485 68/push 0/imm32/right:null -33486 68/push 0/imm32/left:unused -33487 68/push 0/imm32/value:literal -33488 68/push 1/imm32/is-atom?:true -33489 68/push 0x11/imm32/alloc-id:fake:payload -33490 89/<- %edx 4/r32/esp -33491 $test-add-literal-to-eax:initialize-literal: -33492 # var l/edx: (payload var) -33493 68/push 0/imm32/register -33494 68/push 0/imm32/register -33495 68/push 0/imm32/no-stack-offset -33496 68/push 1/imm32/block-depth -33497 52/push-edx -33498 68/push 0x11/imm32/alloc-id:fake -33499 68/push 0/imm32/name -33500 68/push 0/imm32/name -33501 68/push 0x11/imm32/alloc-id:fake:payload -33502 89/<- %edx 4/r32/esp -33503 $test-add-literal-to-eax:initialize-literal-value: -33504 # l->name = "0x34" -33505 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -33506 (copy-array Heap "0x34" %eax) -33507 $test-add-literal-to-eax:initialize-inouts: -33508 # var inouts/esi: (payload stmt-var) = [l] -33509 68/push 0/imm32/is-deref:false -33510 68/push 0/imm32/next -33511 68/push 0/imm32/next -33512 52/push-edx/l -33513 68/push 0x11/imm32/alloc-id:fake -33514 68/push 0x11/imm32/alloc-id:fake:payload -33515 89/<- %esi 4/r32/esp -33516 $test-add-literal-to-eax:initialize-outputs: -33517 # var outputs/edi: (payload stmt-var) = [v] -33518 68/push 0/imm32/is-deref:false -33519 68/push 0/imm32/next -33520 68/push 0/imm32/next -33521 51/push-ecx/v -33522 68/push 0x11/imm32/alloc-id:fake -33523 68/push 0x11/imm32/alloc-id:fake:payload -33524 89/<- %edi 4/r32/esp -33525 $test-add-literal-to-eax:initialize-stmt: -33526 # var stmt/esi: (addr statement) -33527 68/push 0/imm32/next -33528 68/push 0/imm32/next -33529 57/push-edi/outputs -33530 68/push 0x11/imm32/alloc-id:fake -33531 56/push-esi/inouts -33532 68/push 0x11/imm32/alloc-id:fake -33533 68/push 0/imm32/operation -33534 68/push 0/imm32/operation -33535 68/push 1/imm32/tag:stmt1 -33536 89/<- %esi 4/r32/esp -33537 $test-add-literal-to-eax:initialize-stmt-operation: -33538 # stmt->operation = "add" -33539 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -33540 (copy-array Heap "add" %eax) -33541 # convert -33542 c7 0/subop/copy *Curr-block-depth 0/imm32 -33543 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -33544 (flush _test-output-buffered-file) -33545 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -33551 # check output -33552 (check-next-stream-line-equal _test-output-stream "05/add-to-eax 0x34/imm32" "F - test-add-literal-to-eax") -33553 # . epilogue -33554 89/<- %esp 5/r32/ebp -33555 5d/pop-to-ebp -33556 c3/return -33557 -33558 test-add-literal-to-reg: -33559 # var1/ecx <- add 0x34 +33474 $test-emit-subx-stmt-primitive:initialize-var: +33475 # var var-foo/ecx: (payload var) = var(type) +33476 68/push 0/imm32/no-register +33477 68/push 0/imm32/no-register +33478 68/push -8/imm32/stack-offset +33479 68/push 1/imm32/block-depth +33480 51/push-ecx/type +33481 68/push 0x11/imm32/alloc-id:fake +33482 68/push 0/imm32/name +33483 68/push 0/imm32/name +33484 68/push 0x11/imm32/alloc-id:fake:payload +33485 89/<- %ecx 4/r32/esp +33486 $test-emit-subx-stmt-primitive:initialize-var-name: +33487 # var-foo->name = "foo" +33488 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +33489 (copy-array Heap "foo" %eax) +33490 $test-emit-subx-stmt-primitive:initialize-stmt-var: +33491 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) +33492 68/push 0/imm32/is-deref:false +33493 68/push 0/imm32/next +33494 68/push 0/imm32/next +33495 51/push-ecx/var-foo +33496 68/push 0x11/imm32/alloc-id:fake +33497 68/push 0x11/imm32/alloc-id:fake:payload +33498 89/<- %ebx 4/r32/esp +33499 $test-emit-subx-stmt-primitive:initialize-stmt: +33500 # var stmt/esi: (addr statement) +33501 68/push 0/imm32/no-outputs +33502 68/push 0/imm32/no-outputs +33503 53/push-ebx/inouts +33504 68/push 0x11/imm32/alloc-id:fake +33505 68/push 0/imm32/operation +33506 68/push 0/imm32/operation +33507 68/push 1/imm32/tag +33508 89/<- %esi 4/r32/esp +33509 $test-emit-subx-stmt-primitive:initialize-stmt-operation: +33510 # stmt->operation = "increment" +33511 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +33512 (copy-array Heap "increment" %eax) +33513 $test-emit-subx-stmt-primitive:initialize-primitive: +33514 # var primitives/ebx: (addr primitive) +33515 68/push 0/imm32/next +33516 68/push 0/imm32/next +33517 68/push 0/imm32/no-x32 +33518 68/push 0/imm32/no-xm32 +33519 68/push 0/imm32/no-disp32 +33520 68/push 0/imm32/no-imm8 +33521 68/push 0/imm32/no-imm32 +33522 68/push 0/imm32/no-r32 +33523 68/push 1/imm32/rm32-is-first-inout +33524 68/push 0/imm32/subx-name +33525 68/push 0/imm32/subx-name +33526 68/push 0/imm32/no-outputs +33527 68/push 0/imm32/no-outputs +33528 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration +33529 68/push 0x11/imm32/alloc-id:fake +33530 68/push 0/imm32/name +33531 68/push 0/imm32/name +33532 89/<- %ebx 4/r32/esp +33533 $test-emit-subx-stmt-primitive:initialize-primitive-name: +33534 # primitives->name = "increment" +33535 (copy-array Heap "increment" %ebx) # Primitive-name +33536 $test-emit-subx-stmt-primitive:initialize-primitive-subx-name: +33537 # primitives->subx-name = "ff 0/subop/increment" +33538 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +33539 (copy-array Heap "ff 0/subop/increment" %eax) +33540 # convert +33541 c7 0/subop/copy *Curr-block-depth 0/imm32 +33542 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) +33543 (flush _test-output-buffered-file) +33544 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +33550 # check output +33551 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment *(ebp+0xfffffff8)" "F - test-emit-subx-stmt-primitive") +33552 # . epilogue +33553 89/<- %esp 5/r32/ebp +33554 5d/pop-to-ebp +33555 c3/return +33556 +33557 test-emit-subx-stmt-primitive-register: +33558 # Primitive operation on a variable in a register. +33559 # foo <- increment 33560 # => -33561 # 81 0/subop/add %ecx 0x34/imm32 +33561 # ff 0/subop/increment %eax # sub-optimal, but should suffice 33562 # -33563 # . prologue -33564 55/push-ebp -33565 89/<- %ebp 4/r32/esp -33566 # setup -33567 (clear-stream _test-output-stream) -33568 (clear-stream $_test-output-buffered-file->buffer) -33569 $test-add-literal-to-reg:initialize-var-type: -33570 # var type/ecx: (payload type-tree) = int -33571 68/push 0/imm32/right:null -33572 68/push 0/imm32/right:null -33573 68/push 0/imm32/left:unused -33574 68/push 1/imm32/value:int -33575 68/push 1/imm32/is-atom?:true -33576 68/push 0x11/imm32/alloc-id:fake:payload -33577 89/<- %ecx 4/r32/esp -33578 $test-add-literal-to-reg:initialize-var: -33579 # var v/ecx: (payload var) -33580 68/push 0/imm32/register -33581 68/push 0/imm32/register -33582 68/push 0/imm32/no-stack-offset -33583 68/push 1/imm32/block-depth -33584 51/push-ecx -33585 68/push 0x11/imm32/alloc-id:fake -33586 68/push 0/imm32/name -33587 68/push 0/imm32/name -33588 68/push 0x11/imm32/alloc-id:fake:payload -33589 89/<- %ecx 4/r32/esp -33590 $test-add-literal-to-reg:initialize-var-name: -33591 # v->name = "v" -33592 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -33593 (copy-array Heap "v" %eax) -33594 $test-add-literal-to-reg:initialize-var-register: -33595 # v->register = "ecx" -33596 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -33597 (copy-array Heap "ecx" %eax) -33598 $test-add-literal-to-reg:initialize-literal-type: -33599 # var type/edx: (payload type-tree) = literal -33600 68/push 0/imm32/right:null -33601 68/push 0/imm32/right:null -33602 68/push 0/imm32/left:unused -33603 68/push 0/imm32/value:literal -33604 68/push 1/imm32/is-atom?:true -33605 68/push 0x11/imm32/alloc-id:fake:payload -33606 89/<- %edx 4/r32/esp -33607 $test-add-literal-to-reg:initialize-literal: -33608 # var l/edx: (payload var) -33609 68/push 0/imm32/register -33610 68/push 0/imm32/register -33611 68/push 0/imm32/no-stack-offset -33612 68/push 1/imm32/block-depth -33613 52/push-edx +33563 # There's a variable on the var stack as follows: +33564 # name: 'foo' +33565 # type: int +33566 # register: 'eax' +33567 # +33568 # There's a primitive with this info: +33569 # name: 'increment' +33570 # out: int/reg +33571 # value: 'ff 0/subop/increment' +33572 # +33573 # . prologue +33574 55/push-ebp +33575 89/<- %ebp 4/r32/esp +33576 # setup +33577 (clear-stream _test-output-stream) +33578 (clear-stream $_test-output-buffered-file->buffer) +33579 $test-emit-subx-stmt-primitive-register:initialize-type: +33580 # var type/ecx: (payload type-tree) = int +33581 68/push 0/imm32/right:null +33582 68/push 0/imm32/right:null +33583 68/push 0/imm32/left:unused +33584 68/push 1/imm32/value:int +33585 68/push 1/imm32/is-atom?:true +33586 68/push 0x11/imm32/alloc-id:fake:payload +33587 89/<- %ecx 4/r32/esp +33588 $test-emit-subx-stmt-primitive-register:initialize-var: +33589 # var var-foo/ecx: (payload var) +33590 68/push 0/imm32/register +33591 68/push 0/imm32/register +33592 68/push 0/imm32/no-stack-offset +33593 68/push 1/imm32/block-depth +33594 51/push-ecx +33595 68/push 0x11/imm32/alloc-id:fake +33596 68/push 0/imm32/name +33597 68/push 0/imm32/name +33598 68/push 0x11/imm32/alloc-id:fake:payload +33599 89/<- %ecx 4/r32/esp +33600 $test-emit-subx-stmt-primitive-register:initialize-var-name: +33601 # var-foo->name = "foo" +33602 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +33603 (copy-array Heap "foo" %eax) +33604 $test-emit-subx-stmt-primitive-register:initialize-var-register: +33605 # var-foo->register = "eax" +33606 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +33607 (copy-array Heap "eax" %eax) +33608 $test-emit-subx-stmt-primitive-register:initialize-stmt-var: +33609 # var operand/ebx: (payload stmt-var) +33610 68/push 0/imm32/is-deref:false +33611 68/push 0/imm32/next +33612 68/push 0/imm32/next +33613 51/push-ecx/var-foo 33614 68/push 0x11/imm32/alloc-id:fake -33615 68/push 0/imm32/name -33616 68/push 0/imm32/name -33617 68/push 0x11/imm32/alloc-id:fake:payload -33618 89/<- %edx 4/r32/esp -33619 $test-add-literal-to-reg:initialize-literal-value: -33620 # l->name = "0x34" -33621 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -33622 (copy-array Heap "0x34" %eax) -33623 $test-add-literal-to-reg:initialize-inouts: -33624 # var inouts/esi: (payload stmt-var) = [l] -33625 68/push 0/imm32/is-deref:false -33626 68/push 0/imm32/next -33627 68/push 0/imm32/next -33628 52/push-edx/l -33629 68/push 0x11/imm32/alloc-id:fake -33630 68/push 0x11/imm32/alloc-id:fake:payload -33631 89/<- %esi 4/r32/esp -33632 $test-add-literal-to-reg:initialize-outputs: -33633 # var outputs/edi: (payload stmt-var) = [v] -33634 68/push 0/imm32/is-deref:false -33635 68/push 0/imm32/next -33636 68/push 0/imm32/next -33637 51/push-ecx/v +33615 68/push 0x11/imm32/alloc-id:fake:payload +33616 89/<- %ebx 4/r32/esp +33617 $test-emit-subx-stmt-primitive-register:initialize-stmt: +33618 # var stmt/esi: (addr statement) +33619 53/push-ebx/outputs +33620 68/push 0x11/imm32/alloc-id:fake +33621 68/push 0/imm32/no-inouts +33622 68/push 0/imm32/no-inouts +33623 68/push 0/imm32/operation +33624 68/push 0/imm32/operation +33625 68/push 1/imm32 +33626 89/<- %esi 4/r32/esp +33627 $test-emit-subx-stmt-primitive-register:initialize-stmt-operation: +33628 # stmt->operation = "increment" +33629 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +33630 (copy-array Heap "increment" %eax) +33631 $test-emit-subx-stmt-primitive-register:initialize-formal-var: +33632 # var formal-var/ebx: (payload var) +33633 68/push 0/imm32/register +33634 68/push 0/imm32/register +33635 68/push 0/imm32/no-stack-offset +33636 68/push 1/imm32/block-depth +33637 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id 33638 68/push 0x11/imm32/alloc-id:fake -33639 68/push 0x11/imm32/alloc-id:fake:payload -33640 89/<- %edi 4/r32/esp -33641 $test-add-literal-to-reg:initialize-stmt: -33642 # var stmt/esi: (addr statement) -33643 68/push 0/imm32/next -33644 68/push 0/imm32/next -33645 57/push-edi/outputs -33646 68/push 0x11/imm32/alloc-id:fake -33647 56/push-esi/inouts -33648 68/push 0x11/imm32/alloc-id:fake -33649 68/push 0/imm32/operation -33650 68/push 0/imm32/operation -33651 68/push 1/imm32/tag:stmt1 -33652 89/<- %esi 4/r32/esp -33653 $test-add-literal-to-reg:initialize-stmt-operation: -33654 # stmt->operation = "add" -33655 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -33656 (copy-array Heap "add" %eax) -33657 # convert -33658 c7 0/subop/copy *Curr-block-depth 0/imm32 -33659 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -33660 (flush _test-output-buffered-file) -33661 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -33667 # check output -33668 (check-next-stream-line-equal _test-output-stream "81 0/subop/add %ecx 0x34/imm32" "F - test-add-literal-to-reg") -33669 # . epilogue -33670 89/<- %esp 5/r32/ebp -33671 5d/pop-to-ebp -33672 c3/return -33673 -33674 test-add-literal-to-mem: -33675 # add-to var1, 0x34 -33676 # => -33677 # 81 0/subop/add %eax 0x34/imm32 -33678 # -33679 # . prologue -33680 55/push-ebp -33681 89/<- %ebp 4/r32/esp -33682 # setup -33683 (clear-stream _test-output-stream) -33684 (clear-stream $_test-output-buffered-file->buffer) -33685 $test-add-literal-to-mem:initialize-type: -33686 # var type/ecx: (payload type-tree) = int -33687 68/push 0/imm32/right:null -33688 68/push 0/imm32/right:null -33689 68/push 0/imm32/left:unused -33690 68/push 1/imm32/value:int -33691 68/push 1/imm32/is-atom?:true -33692 68/push 0x11/imm32/alloc-id:fake:payload -33693 89/<- %ecx 4/r32/esp -33694 $test-add-literal-to-mem:initialize-var1: -33695 # var var1/ecx: (payload var) -33696 68/push 0/imm32/register -33697 68/push 0/imm32/register -33698 68/push 8/imm32/stack-offset -33699 68/push 1/imm32/block-depth -33700 51/push-ecx -33701 68/push 0x11/imm32/alloc-id:fake -33702 68/push 0/imm32/name -33703 68/push 0/imm32/name -33704 68/push 0x11/imm32/alloc-id:fake:payload -33705 89/<- %ecx 4/r32/esp -33706 $test-add-literal-to-mem:initialize-var1-name: -33707 # var1->name = "var1" -33708 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -33709 (copy-array Heap "var1" %eax) -33710 $test-add-literal-to-mem:initialize-literal-type: -33711 # var type/edx: (payload type-tree) = literal -33712 68/push 0/imm32/right:null -33713 68/push 0/imm32/right:null -33714 68/push 0/imm32/left:unused -33715 68/push 0/imm32/value:literal -33716 68/push 1/imm32/is-atom?:true -33717 68/push 0x11/imm32/alloc-id:fake:payload -33718 89/<- %edx 4/r32/esp -33719 $test-add-literal-to-mem:initialize-literal: -33720 # var l/edx: (payload var) -33721 68/push 0/imm32/register -33722 68/push 0/imm32/register -33723 68/push 0/imm32/no-stack-offset -33724 68/push 1/imm32/block-depth -33725 52/push-edx -33726 68/push 0x11/imm32/alloc-id:fake -33727 68/push 0/imm32/name -33728 68/push 0/imm32/name -33729 68/push 0x11/imm32/alloc-id:fake:payload -33730 89/<- %edx 4/r32/esp -33731 $test-add-literal-to-mem:initialize-literal-value: -33732 # l->name = "0x34" -33733 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -33734 (copy-array Heap "0x34" %eax) -33735 $test-add-literal-to-mem:initialize-inouts: -33736 # var inouts/esi: (payload stmt-var) = [l] -33737 68/push 0/imm32/is-deref:false -33738 68/push 0/imm32/next -33739 68/push 0/imm32/next -33740 52/push-edx/l -33741 68/push 0x11/imm32/alloc-id:fake -33742 68/push 0x11/imm32/alloc-id:fake:payload -33743 89/<- %esi 4/r32/esp -33744 # var inouts = (handle stmt-var) = [var1, var2] -33745 68/push 0/imm32/is-deref:false -33746 56/push-esi/next -33747 68/push 0x11/imm32/alloc-id:fake -33748 51/push-ecx/var1 -33749 68/push 0x11/imm32/alloc-id:fake -33750 68/push 0x11/imm32/alloc-id:fake:payload -33751 89/<- %esi 4/r32/esp -33752 $test-add-literal-to-mem:initialize-stmt: -33753 # var stmt/esi: (addr statement) -33754 68/push 0/imm32/next -33755 68/push 0/imm32/next -33756 68/push 0/imm32/outputs -33757 68/push 0/imm32/outputs -33758 56/push-esi/inouts -33759 68/push 0x11/imm32/alloc-id:fake -33760 68/push 0/imm32/operation -33761 68/push 0/imm32/operation -33762 68/push 1/imm32/tag:stmt1 -33763 89/<- %esi 4/r32/esp -33764 $test-add-literal-to-mem:initialize-stmt-operation: -33765 # stmt->operation = "add-to" -33766 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -33767 (copy-array Heap "add-to" %eax) -33768 # convert -33769 c7 0/subop/copy *Curr-block-depth 0/imm32 -33770 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -33771 (flush _test-output-buffered-file) -33772 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -33778 # check output -33779 (check-next-stream-line-equal _test-output-stream "81 0/subop/add *(ebp+0x00000008) 0x34/imm32" "F - test-add-literal-to-mem") -33780 # . epilogue -33781 89/<- %esp 5/r32/ebp -33782 5d/pop-to-ebp -33783 c3/return -33784 -33785 test-shift-reg-by-literal: -33786 # var1/ecx <- shift-left 2 -33787 # => -33788 # c1/shift 4/subop/left %ecx 2/imm8 -33789 # -33790 # . prologue -33791 55/push-ebp -33792 89/<- %ebp 4/r32/esp -33793 # setup -33794 (clear-stream _test-output-stream) -33795 (clear-stream $_test-output-buffered-file->buffer) -33796 $test-shift-reg-by-literal:initialize-var-type: -33797 # var type/ecx: (payload type-tree) = int -33798 68/push 0/imm32/right:null -33799 68/push 0/imm32/right:null -33800 68/push 0/imm32/left:unused -33801 68/push 1/imm32/value:int -33802 68/push 1/imm32/is-atom?:true -33803 68/push 0x11/imm32/alloc-id:fake:payload -33804 89/<- %ecx 4/r32/esp -33805 $test-shift-reg-by-literal:initialize-var: -33806 # var v/ecx: (payload var) -33807 68/push 0/imm32/register -33808 68/push 0/imm32/register -33809 68/push 0/imm32/no-stack-offset -33810 68/push 1/imm32/block-depth -33811 51/push-ecx -33812 68/push 0x11/imm32/alloc-id:fake -33813 68/push 0/imm32/name -33814 68/push 0/imm32/name -33815 68/push 0x11/imm32/alloc-id:fake:payload -33816 89/<- %ecx 4/r32/esp -33817 $test-shift-reg-by-literal:initialize-var-name: -33818 # v->name = "v" -33819 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -33820 (copy-array Heap "v" %eax) -33821 $test-shift-reg-by-literal:initialize-var-register: -33822 # v->register = "ecx" -33823 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -33824 (copy-array Heap "ecx" %eax) -33825 $test-shift-reg-by-literal:initialize-literal-type: -33826 # var type/edx: (payload type-tree) = literal -33827 68/push 0/imm32/right:null -33828 68/push 0/imm32/right:null -33829 68/push 0/imm32/left:unused -33830 68/push 0/imm32/value:literal -33831 68/push 1/imm32/is-atom?:true -33832 68/push 0x11/imm32/alloc-id:fake:payload -33833 89/<- %edx 4/r32/esp -33834 $test-shift-reg-by-literal:initialize-literal: -33835 # var l/edx: (payload var) -33836 68/push 0/imm32/register -33837 68/push 0/imm32/register -33838 68/push 0/imm32/no-stack-offset -33839 68/push 1/imm32/block-depth -33840 52/push-edx -33841 68/push 0x11/imm32/alloc-id:fake -33842 68/push 0/imm32/name -33843 68/push 0/imm32/name -33844 68/push 0x11/imm32/alloc-id:fake:payload -33845 89/<- %edx 4/r32/esp -33846 $test-shift-reg-by-literal:initialize-literal-value: -33847 # l->name = "2" -33848 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -33849 (copy-array Heap "2" %eax) -33850 $test-shift-reg-by-literal:initialize-inouts: -33851 # var inouts/esi: (payload stmt-var) = [l] -33852 68/push 0/imm32/is-deref:false -33853 68/push 0/imm32/next -33854 68/push 0/imm32/next -33855 52/push-edx/l -33856 68/push 0x11/imm32/alloc-id:fake -33857 68/push 0x11/imm32/alloc-id:fake:payload -33858 89/<- %esi 4/r32/esp -33859 $test-shift-reg-by-literal:initialize-outputs: -33860 # var outputs/edi: (payload stmt-var) = [v] -33861 68/push 0/imm32/is-deref:false -33862 68/push 0/imm32/next -33863 68/push 0/imm32/next -33864 51/push-ecx/v -33865 68/push 0x11/imm32/alloc-id:fake -33866 68/push 0x11/imm32/alloc-id:fake:payload -33867 89/<- %edi 4/r32/esp -33868 $test-shift-reg-by-literal:initialize-stmt: -33869 # var stmt/esi: (addr statement) -33870 68/push 0/imm32/next -33871 68/push 0/imm32/next -33872 57/push-edi/outputs -33873 68/push 0x11/imm32/alloc-id:fake -33874 56/push-esi/inouts -33875 68/push 0x11/imm32/alloc-id:fake -33876 68/push 0/imm32/operation -33877 68/push 0/imm32/operation -33878 68/push 1/imm32/tag:stmt1 -33879 89/<- %esi 4/r32/esp -33880 $test-shift-reg-by-literal:initialize-stmt-operation: -33881 # stmt->operation = "shift-left" -33882 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -33883 (copy-array Heap "shift-left" %eax) -33884 # convert -33885 c7 0/subop/copy *Curr-block-depth 0/imm32 -33886 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -33887 (flush _test-output-buffered-file) -33888 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -33894 # check output -33895 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left %ecx 2/imm8" "F - test-shift-reg-by-literal") -33896 # . epilogue -33897 89/<- %esp 5/r32/ebp -33898 5d/pop-to-ebp -33899 c3/return -33900 -33901 test-shift-mem-by-literal: -33902 # shift-left var 3 -33903 # => -33904 # c1/shift 4/subop/left *(ebp+8) 3/imm8 -33905 # -33906 # . prologue -33907 55/push-ebp -33908 89/<- %ebp 4/r32/esp -33909 # setup -33910 (clear-stream _test-output-stream) -33911 (clear-stream $_test-output-buffered-file->buffer) -33912 $test-shift-mem-by-literal:initialize-type: -33913 # var type/ecx: (payload type-tree) = int -33914 68/push 0/imm32/right:null -33915 68/push 0/imm32/right:null -33916 68/push 0/imm32/left:unused -33917 68/push 1/imm32/value:int -33918 68/push 1/imm32/is-atom?:true -33919 68/push 0x11/imm32/alloc-id:fake:payload -33920 89/<- %ecx 4/r32/esp -33921 $test-shift-mem-by-literal:initialize-var1: -33922 # var var1/ecx: (payload var) -33923 68/push 0/imm32/register -33924 68/push 0/imm32/register -33925 68/push 8/imm32/stack-offset -33926 68/push 1/imm32/block-depth -33927 51/push-ecx -33928 68/push 0x11/imm32/alloc-id:fake -33929 68/push 0/imm32/name -33930 68/push 0/imm32/name -33931 68/push 0x11/imm32/alloc-id:fake:payload -33932 89/<- %ecx 4/r32/esp -33933 $test-shift-mem-by-literal:initialize-var1-name: -33934 # var1->name = "var1" -33935 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -33936 (copy-array Heap "var1" %eax) -33937 $test-shift-mem-by-literal:initialize-literal-type: -33938 # var type/edx: (payload type-tree) = literal -33939 68/push 0/imm32/right:null -33940 68/push 0/imm32/right:null -33941 68/push 0/imm32/left:unused -33942 68/push 0/imm32/value:literal -33943 68/push 1/imm32/is-atom?:true -33944 68/push 0x11/imm32/alloc-id:fake:payload -33945 89/<- %edx 4/r32/esp -33946 $test-shift-mem-by-literal:initialize-literal: -33947 # var l/edx: (payload var) -33948 68/push 0/imm32/register -33949 68/push 0/imm32/register -33950 68/push 0/imm32/no-stack-offset -33951 68/push 1/imm32/block-depth -33952 52/push-edx -33953 68/push 0x11/imm32/alloc-id:fake -33954 68/push 0/imm32/name -33955 68/push 0/imm32/name -33956 68/push 0x11/imm32/alloc-id:fake:payload -33957 89/<- %edx 4/r32/esp -33958 $test-shift-mem-by-literal:initialize-literal-value: -33959 # l->name = "3" -33960 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -33961 (copy-array Heap "3" %eax) -33962 $test-shift-mem-by-literal:initialize-inouts: -33963 # var inouts/esi: (payload stmt-var) = [l] -33964 68/push 0/imm32/is-deref:false -33965 68/push 0/imm32/next -33966 68/push 0/imm32/next -33967 52/push-edx/l -33968 68/push 0x11/imm32/alloc-id:fake -33969 68/push 0x11/imm32/alloc-id:fake:payload -33970 89/<- %esi 4/r32/esp -33971 # var inouts = (handle stmt-var) = [var1, var2] -33972 68/push 0/imm32/is-deref:false -33973 56/push-esi/next -33974 68/push 0x11/imm32/alloc-id:fake -33975 51/push-ecx/var1 -33976 68/push 0x11/imm32/alloc-id:fake -33977 68/push 0x11/imm32/alloc-id:fake:payload -33978 89/<- %esi 4/r32/esp -33979 $test-shift-mem-by-literal:initialize-stmt: -33980 # var stmt/esi: (addr statement) +33639 68/push 0/imm32/name +33640 68/push 0/imm32/name +33641 68/push 0x11/imm32/alloc-id:fake:payload +33642 89/<- %ebx 4/r32/esp +33643 $test-emit-subx-stmt-primitive-register:initialize-formal-var-name: +33644 # formal-var->name = "dummy" +33645 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 +33646 (copy-array Heap "dummy" %eax) +33647 $test-emit-subx-stmt-primitive-register:initialize-formal-register: +33648 # formal-var->register = "*" +33649 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 +33650 (copy-array Heap "*" %eax) # Any-register +33651 $test-emit-subx-stmt-primitive-register:initialize-var-list: +33652 # var formal-outputs/ebx: (payload list var) +33653 68/push 0/imm32/next +33654 68/push 0/imm32/next +33655 53/push-ebx/formal-var +33656 68/push 0x11/imm32/alloc-id:fake +33657 68/push 0x11/imm32/alloc-id:fake:payload +33658 89/<- %ebx 4/r32/esp +33659 $test-emit-subx-stmt-primitive-register:initialize-primitive: +33660 # var primitives/ebx: (addr primitive) +33661 68/push 0/imm32/next +33662 68/push 0/imm32/next +33663 68/push 0/imm32/no-x32 +33664 68/push 0/imm32/no-xm32 +33665 68/push 0/imm32/no-disp32 +33666 68/push 0/imm32/no-imm8 +33667 68/push 0/imm32/no-imm32 +33668 68/push 0/imm32/no-r32 +33669 68/push 3/imm32/rm32-is-first-output +33670 68/push 0/imm32/subx-name +33671 68/push 0/imm32/subx-name +33672 53/push-ebx/outputs +33673 68/push 0x11/imm32/alloc-id:fake +33674 68/push 0/imm32/no-inouts +33675 68/push 0/imm32/no-inouts +33676 68/push 0/imm32/name +33677 68/push 0/imm32/name +33678 89/<- %ebx 4/r32/esp +33679 $test-emit-subx-stmt-primitive-register:initialize-primitive-name: +33680 # primitives->name = "increment" +33681 (copy-array Heap "increment" %ebx) # Primitive-name +33682 $test-emit-subx-stmt-primitive-register:initialize-primitive-subx-name: +33683 # primitives->subx-name = "ff 0/subop/increment" +33684 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +33685 (copy-array Heap "ff 0/subop/increment" %eax) +33686 # convert +33687 c7 0/subop/copy *Curr-block-depth 0/imm32 +33688 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) +33689 (flush _test-output-buffered-file) +33690 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +33696 # check output +33697 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-primitive-register") +33698 # . epilogue +33699 89/<- %esp 5/r32/ebp +33700 5d/pop-to-ebp +33701 c3/return +33702 +33703 test-emit-subx-stmt-select-primitive: +33704 # Select the right primitive between overloads. +33705 # foo <- increment +33706 # => +33707 # ff 0/subop/increment %eax # sub-optimal, but should suffice +33708 # +33709 # There's a variable on the var stack as follows: +33710 # name: 'foo' +33711 # type: int +33712 # register: 'eax' +33713 # +33714 # There's two primitives, as follows: +33715 # - name: 'increment' +33716 # out: int/reg +33717 # value: 'ff 0/subop/increment' +33718 # - name: 'increment' +33719 # inout: int/mem +33720 # value: 'ff 0/subop/increment' +33721 # +33722 # . prologue +33723 55/push-ebp +33724 89/<- %ebp 4/r32/esp +33725 # setup +33726 (clear-stream _test-output-stream) +33727 (clear-stream $_test-output-buffered-file->buffer) +33728 $test-emit-subx-stmt-select-primitive:initialize-type: +33729 # var type/ecx: (payload type-tree) = int +33730 68/push 0/imm32/right:null +33731 68/push 0/imm32/right:null +33732 68/push 0/imm32/left:unused +33733 68/push 1/imm32/value:int +33734 68/push 1/imm32/is-atom?:true +33735 68/push 0x11/imm32/alloc-id:fake:payload +33736 89/<- %ecx 4/r32/esp +33737 $test-emit-subx-stmt-select-primitive:initialize-var: +33738 # var var-foo/ecx: (payload var) +33739 68/push 0/imm32/register +33740 68/push 0/imm32/register +33741 68/push 0/imm32/no-stack-offset +33742 68/push 1/imm32/block-depth +33743 51/push-ecx +33744 68/push 0x11/imm32/alloc-id:fake +33745 68/push 0/imm32/name +33746 68/push 0/imm32/name +33747 68/push 0x11/imm32/alloc-id:fake:payload +33748 89/<- %ecx 4/r32/esp +33749 $test-emit-subx-stmt-select-primitive:initialize-var-name: +33750 # var-foo->name = "foo" +33751 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +33752 (copy-array Heap "foo" %eax) +33753 $test-emit-subx-stmt-select-primitive:initialize-var-register: +33754 # var-foo->register = "eax" +33755 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +33756 (copy-array Heap "eax" %eax) +33757 $test-emit-subx-stmt-select-primitive:initialize-stmt-var: +33758 # var operand/ebx: (payload stmt-var) +33759 68/push 0/imm32/is-deref:false +33760 68/push 0/imm32/next +33761 68/push 0/imm32/next +33762 51/push-ecx/var-foo +33763 68/push 0x11/imm32/alloc-id:fake +33764 68/push 0x11/imm32/alloc-id:fake:payload +33765 89/<- %ebx 4/r32/esp +33766 $test-emit-subx-stmt-select-primitive:initialize-stmt: +33767 # var stmt/esi: (addr statement) +33768 53/push-ebx/outputs +33769 68/push 0x11/imm32/alloc-id:fake +33770 68/push 0/imm32/no-inouts +33771 68/push 0/imm32/no-inouts +33772 68/push 0/imm32/operation +33773 68/push 0/imm32/operation +33774 68/push 1/imm32 +33775 89/<- %esi 4/r32/esp +33776 $test-emit-subx-stmt-select-primitive:initialize-stmt-operation: +33777 # stmt->operation = "increment" +33778 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +33779 (copy-array Heap "increment" %eax) +33780 $test-emit-subx-stmt-select-primitive:initialize-formal-var: +33781 # var formal-var/ebx: (payload var) +33782 68/push 0/imm32/register +33783 68/push 0/imm32/register +33784 68/push 0/imm32/no-stack-offset +33785 68/push 1/imm32/block-depth +33786 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id +33787 68/push 0x11/imm32/alloc-id:fake +33788 68/push 0/imm32/name +33789 68/push 0/imm32/name +33790 68/push 0x11/imm32/alloc-id:fake:payload +33791 89/<- %ebx 4/r32/esp +33792 $test-emit-subx-stmt-select-primitive:initialize-formal-var-name: +33793 # formal-var->name = "dummy" +33794 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 +33795 (copy-array Heap "dummy" %eax) +33796 $test-emit-subx-stmt-select-primitive:initialize-formal-register: +33797 # formal-var->register = "*" +33798 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 +33799 (copy-array Heap "*" %eax) # Any-register +33800 $test-emit-subx-stmt-select-primitive:initialize-var-list: +33801 # var formal-outputs/ebx: (payload list var) +33802 68/push 0/imm32/next +33803 68/push 0/imm32/next +33804 53/push-ebx/formal-var +33805 68/push 0x11/imm32/alloc-id:fake +33806 68/push 0x11/imm32/alloc-id:fake:payload +33807 89/<- %ebx 4/r32/esp +33808 $test-emit-subx-stmt-select-primitive:initialize-primitive2: +33809 # var primitive2/edi: (payload primitive) +33810 68/push 0/imm32/next +33811 68/push 0/imm32/next +33812 68/push 0/imm32/no-x32 +33813 68/push 0/imm32/no-xm32 +33814 68/push 0/imm32/no-disp32 +33815 68/push 0/imm32/no-imm8 +33816 68/push 0/imm32/no-imm32 +33817 68/push 0/imm32/no-r32 +33818 68/push 3/imm32/rm32-is-first-output +33819 68/push 0/imm32/subx-name +33820 68/push 0/imm32/subx-name +33821 53/push-ebx/outputs +33822 68/push 0x11/imm32/alloc-id:fake +33823 68/push 0/imm32/no-inouts +33824 68/push 0/imm32/no-inouts +33825 68/push 0/imm32/name +33826 68/push 0/imm32/name +33827 68/push 0x11/imm32/alloc-id:fake:payload +33828 89/<- %edi 4/r32/esp +33829 $test-emit-subx-stmt-select-primitive:initialize-primitive2-name: +33830 # primitives->name = "increment" +33831 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 +33832 (copy-array Heap "increment" %eax) +33833 $test-emit-subx-stmt-select-primitive:initialize-primitive2-subx-name: +33834 # primitives->subx-name = "ff 0/subop/increment" +33835 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 +33836 (copy-array Heap "ff 0/subop/increment" %eax) +33837 $test-emit-subx-stmt-select-primitive:initialize-primitive: +33838 # var primitives/ebx: (addr primitive) +33839 57/push-edi +33840 68/push 0x11/imm32/alloc-id:fake +33841 68/push 0/imm32/no-x32 +33842 68/push 0/imm32/no-xm32 +33843 68/push 0/imm32/no-disp32 +33844 68/push 0/imm32/no-imm8 +33845 68/push 0/imm32/no-imm32 +33846 68/push 0/imm32/no-r32 +33847 68/push 1/imm32/rm32-is-first-inout +33848 68/push 0/imm32/subx-name +33849 68/push 0/imm32/subx-name +33850 68/push 0/imm32/no-outputs +33851 68/push 0/imm32/no-outputs +33852 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration +33853 68/push 0x11/imm32/alloc-id:fake +33854 68/push 0/imm32/name +33855 68/push 0/imm32/name +33856 89/<- %ebx 4/r32/esp +33857 $test-emit-subx-stmt-select-primitive:initialize-primitive-name: +33858 # primitives->name = "increment" +33859 (copy-array Heap "increment" %ebx) # Primitive-name +33860 $test-emit-subx-stmt-select-primitive:initialize-primitive-subx-name: +33861 # primitives->subx-name = "ff 0/subop/increment" +33862 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +33863 (copy-array Heap "ff 0/subop/increment" %eax) +33864 # convert +33865 c7 0/subop/copy *Curr-block-depth 0/imm32 +33866 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) +33867 (flush _test-output-buffered-file) +33868 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +33874 # check output +33875 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive") +33876 # . epilogue +33877 89/<- %esp 5/r32/ebp +33878 5d/pop-to-ebp +33879 c3/return +33880 +33881 test-emit-subx-stmt-select-primitive-2: +33882 # Select the right primitive between overloads. +33883 # increment foo +33884 # => +33885 # ff 0/subop/increment %eax # sub-optimal, but should suffice +33886 # +33887 # There's a variable on the var stack as follows: +33888 # name: 'foo' +33889 # type: int +33890 # register: 'eax' +33891 # +33892 # There's two primitives, as follows: +33893 # - name: 'increment' +33894 # out: int/reg +33895 # value: 'ff 0/subop/increment' +33896 # - name: 'increment' +33897 # inout: int/mem +33898 # value: 'ff 0/subop/increment' +33899 # +33900 # . prologue +33901 55/push-ebp +33902 89/<- %ebp 4/r32/esp +33903 # setup +33904 (clear-stream _test-output-stream) +33905 (clear-stream $_test-output-buffered-file->buffer) +33906 $test-emit-subx-stmt-select-primitive-2:initialize-type: +33907 # var type/ecx: (payload type-tree) = int +33908 68/push 0/imm32/right:null +33909 68/push 0/imm32/right:null +33910 68/push 0/imm32/left:unused +33911 68/push 1/imm32/value:int +33912 68/push 1/imm32/is-atom?:true +33913 68/push 0x11/imm32/alloc-id:fake:payload +33914 89/<- %ecx 4/r32/esp +33915 $test-emit-subx-stmt-select-primitive-2:initialize-var: +33916 # var var-foo/ecx: (payload var) +33917 68/push 0/imm32/register +33918 68/push 0/imm32/register +33919 68/push 0/imm32/no-stack-offset +33920 68/push 1/imm32/block-depth +33921 51/push-ecx +33922 68/push 0x11/imm32/alloc-id:fake +33923 68/push 0/imm32/name +33924 68/push 0/imm32/name +33925 68/push 0x11/imm32/alloc-id:fake:payload +33926 89/<- %ecx 4/r32/esp +33927 $test-emit-subx-stmt-select-primitive-2:initialize-var-name: +33928 # var-foo->name = "foo" +33929 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +33930 (copy-array Heap "foo" %eax) +33931 $test-emit-subx-stmt-select-primitive-2:initialize-var-register: +33932 # var-foo->register = "eax" +33933 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +33934 (copy-array Heap "eax" %eax) +33935 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-var: +33936 # var operand/ebx: (payload stmt-var) +33937 68/push 0/imm32/is-deref:false +33938 68/push 0/imm32/next +33939 68/push 0/imm32/next +33940 51/push-ecx/var-foo +33941 68/push 0x11/imm32/alloc-id:fake +33942 68/push 0x11/imm32/alloc-id:fake:payload +33943 89/<- %ebx 4/r32/esp +33944 $test-emit-subx-stmt-select-primitive-2:initialize-stmt: +33945 # var stmt/esi: (addr statement) +33946 68/push 0/imm32/no-outputs +33947 68/push 0/imm32/no-outputs +33948 53/push-ebx/inouts +33949 68/push 0x11/imm32/alloc-id:fake +33950 68/push 0/imm32/operation +33951 68/push 0/imm32/operation +33952 68/push 1/imm32 +33953 89/<- %esi 4/r32/esp +33954 $test-emit-subx-stmt-select-primitive-2:initialize-stmt-operation: +33955 # stmt->operation = "increment" +33956 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +33957 (copy-array Heap "increment" %eax) +33958 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var: +33959 # var formal-var/ebx: (payload var) +33960 68/push 0/imm32/register +33961 68/push 0/imm32/register +33962 68/push 0/imm32/no-stack-offset +33963 68/push 1/imm32/block-depth +33964 ff 6/subop/push *(ecx+0x10) # Var-type + payload alloc id + handle alloc id +33965 68/push 0x11/imm32/alloc-id:fake +33966 68/push 0/imm32/name +33967 68/push 0/imm32/name +33968 68/push 0x11/imm32/alloc-id:fake:payload +33969 89/<- %ebx 4/r32/esp +33970 $test-emit-subx-stmt-select-primitive-2:initialize-formal-var-name: +33971 # formal-var->name = "dummy" +33972 8d/copy-address *(ebx+4) 0/r32/eax # Var-name + 4 +33973 (copy-array Heap "dummy" %eax) +33974 $test-emit-subx-stmt-select-primitive-2:initialize-formal-register: +33975 # formal-var->register = "*" +33976 8d/copy-address *(ebx+0x1c) 0/r32/eax # Var-register + 4 +33977 (copy-array Heap "*" %eax) # Any-register +33978 $test-emit-subx-stmt-select-primitive-2:initialize-var-list: +33979 # var formal-outputs/ebx: (payload list stmt-var) +33980 68/push 0/imm32/next 33981 68/push 0/imm32/next -33982 68/push 0/imm32/next -33983 68/push 0/imm32/outputs -33984 68/push 0/imm32/outputs -33985 56/push-esi/inouts -33986 68/push 0x11/imm32/alloc-id:fake -33987 68/push 0/imm32/operation -33988 68/push 0/imm32/operation -33989 68/push 1/imm32/tag:stmt1 -33990 89/<- %esi 4/r32/esp -33991 $test-shift-mem-by-literal:initialize-stmt-operation: -33992 # stmt->operation = "shift-left" -33993 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -33994 (copy-array Heap "shift-left" %eax) -33995 # convert -33996 c7 0/subop/copy *Curr-block-depth 0/imm32 -33997 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -33998 (flush _test-output-buffered-file) -33999 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -34005 # check output -34006 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left *(ebp+0x00000008) 3/imm8" "F - test-shift-mem-by-literal") -34007 # . epilogue -34008 89/<- %esp 5/r32/ebp -34009 5d/pop-to-ebp -34010 c3/return -34011 -34012 test-compare-reg-with-reg: -34013 # compare var1/ecx, var2/eax -34014 # => -34015 # 39/compare %ecx 0/r32/eax -34016 # -34017 # . prologue -34018 55/push-ebp -34019 89/<- %ebp 4/r32/esp -34020 # setup -34021 (clear-stream _test-output-stream) -34022 (clear-stream $_test-output-buffered-file->buffer) -34023 $test-compare-reg-with-reg:initialize-type: -34024 # var type/ecx: (payload type-tree) = int -34025 68/push 0/imm32/right:null -34026 68/push 0/imm32/right:null -34027 68/push 0/imm32/left:unused -34028 68/push 1/imm32/value:int -34029 68/push 1/imm32/is-atom?:true -34030 68/push 0x11/imm32/alloc-id:fake:payload -34031 89/<- %ecx 4/r32/esp -34032 $test-compare-reg-with-reg:initialize-var1: -34033 # var var1/ecx: (payload var) -34034 68/push 0/imm32/register -34035 68/push 0/imm32/register -34036 68/push 0/imm32/no-stack-offset -34037 68/push 1/imm32/block-depth -34038 51/push-ecx -34039 68/push 0x11/imm32/alloc-id:fake -34040 68/push 0/imm32/name -34041 68/push 0/imm32/name -34042 68/push 0x11/imm32/alloc-id:fake:payload -34043 89/<- %ecx 4/r32/esp -34044 $test-compare-reg-with-reg:initialize-var1-name: -34045 # var1->name = "var1" -34046 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -34047 (copy-array Heap "var1" %eax) -34048 $test-compare-reg-with-reg:initialize-var1-register: -34049 # var1->register = "ecx" -34050 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -34051 (copy-array Heap "ecx" %eax) -34052 $test-compare-reg-with-reg:initialize-var2: -34053 # var var2/edx: (payload var) -34054 68/push 0/imm32/register -34055 68/push 0/imm32/register -34056 68/push 0/imm32/no-stack-offset -34057 68/push 1/imm32/block-depth -34058 ff 6/subop/push *(ecx+0x10) -34059 68/push 0x11/imm32/alloc-id:fake -34060 68/push 0/imm32/name -34061 68/push 0/imm32/name -34062 68/push 0x11/imm32/alloc-id:fake:payload -34063 89/<- %edx 4/r32/esp -34064 $test-compare-reg-with-reg:initialize-var2-name: -34065 # var2->name = "var2" -34066 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -34067 (copy-array Heap "var2" %eax) -34068 $test-compare-reg-with-reg:initialize-var2-register: -34069 # var2->register = "eax" -34070 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -34071 (copy-array Heap "eax" %eax) -34072 $test-compare-reg-with-reg:initialize-inouts: -34073 # var inouts/esi: (payload stmt-var) = [var2] -34074 68/push 0/imm32/is-deref:false -34075 68/push 0/imm32/next -34076 68/push 0/imm32/next -34077 52/push-edx/var2 -34078 68/push 0x11/imm32/alloc-id:fake -34079 68/push 0x11/imm32/alloc-id:fake:payload -34080 89/<- %esi 4/r32/esp -34081 # inouts = [var1, var2] -34082 68/push 0/imm32/is-deref:false -34083 56/push-esi/next -34084 68/push 0x11/imm32/alloc-id:fake -34085 51/push-ecx/var1 -34086 68/push 0x11/imm32/alloc-id:fake -34087 68/push 0x11/imm32/alloc-id:fake:payload -34088 89/<- %esi 4/r32/esp -34089 $test-compare-reg-with-reg:initialize-stmt: -34090 # var stmt/esi: (addr statement) -34091 68/push 0/imm32/next -34092 68/push 0/imm32/next -34093 68/push 0/imm32/outputs -34094 68/push 0/imm32/outputs -34095 56/push-esi/inouts -34096 68/push 0x11/imm32/alloc-id:fake -34097 68/push 0/imm32/operation -34098 68/push 0/imm32/operation -34099 68/push 1/imm32/tag:stmt1 -34100 89/<- %esi 4/r32/esp -34101 $test-compare-reg-with-reg:initialize-stmt-operation: -34102 # stmt->operation = "compare" -34103 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -34104 (copy-array Heap "compare" %eax) -34105 # convert -34106 c7 0/subop/copy *Curr-block-depth 0/imm32 -34107 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -34108 (flush _test-output-buffered-file) -34109 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -34115 # check output -34116 (check-next-stream-line-equal _test-output-stream "39/compare-> %ecx 0x00000000/r32" "F - test-compare-reg-with-reg") -34117 # . epilogue -34118 89/<- %esp 5/r32/ebp -34119 5d/pop-to-ebp -34120 c3/return -34121 -34122 test-compare-mem-with-reg: -34123 # compare var1, var2/eax -34124 # => -34125 # 39/compare *(ebp+___) 0/r32/eax -34126 # -34127 # . prologue -34128 55/push-ebp -34129 89/<- %ebp 4/r32/esp -34130 # setup -34131 (clear-stream _test-output-stream) -34132 (clear-stream $_test-output-buffered-file->buffer) -34133 $test-compare-mem-with-reg:initialize-type: -34134 # var type/ecx: (payload type-tree) = int -34135 68/push 0/imm32/right:null -34136 68/push 0/imm32/right:null -34137 68/push 0/imm32/left:unused -34138 68/push 1/imm32/value:int -34139 68/push 1/imm32/is-atom?:true -34140 68/push 0x11/imm32/alloc-id:fake:payload -34141 89/<- %ecx 4/r32/esp -34142 $test-compare-mem-with-reg:initialize-var1: -34143 # var var1/ecx: (payload var) -34144 68/push 0/imm32/register -34145 68/push 0/imm32/register -34146 68/push 8/imm32/stack-offset -34147 68/push 1/imm32/block-depth -34148 51/push-ecx -34149 68/push 0x11/imm32/alloc-id:fake -34150 68/push 0/imm32/name -34151 68/push 0/imm32/name -34152 68/push 0x11/imm32/alloc-id:fake:payload -34153 89/<- %ecx 4/r32/esp -34154 $test-compare-mem-with-reg:initialize-var1-name: -34155 # var1->name = "var1" -34156 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -34157 (copy-array Heap "var1" %eax) -34158 $test-compare-mem-with-reg:initialize-var2: -34159 # var var2/edx: (payload var) -34160 68/push 0/imm32/register -34161 68/push 0/imm32/register -34162 68/push 0/imm32/no-stack-offset -34163 68/push 1/imm32/block-depth -34164 ff 6/subop/push *(ecx+0x10) -34165 68/push 0x11/imm32/alloc-id:fake -34166 68/push 0/imm32/name -34167 68/push 0/imm32/name -34168 68/push 0x11/imm32/alloc-id:fake:payload -34169 89/<- %edx 4/r32/esp -34170 $test-compare-mem-with-reg:initialize-var2-name: -34171 # var2->name = "var2" -34172 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -34173 (copy-array Heap "var2" %eax) -34174 $test-compare-mem-with-reg:initialize-var2-register: -34175 # var2->register = "eax" -34176 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 -34177 (copy-array Heap "eax" %eax) -34178 $test-compare-mem-with-reg:initialize-inouts: -34179 # var inouts/esi: (payload stmt-var) = [var2] -34180 68/push 0/imm32/is-deref:false -34181 68/push 0/imm32/next -34182 68/push 0/imm32/next -34183 52/push-edx/var2 -34184 68/push 0x11/imm32/alloc-id:fake -34185 68/push 0x11/imm32/alloc-id:fake:payload -34186 89/<- %esi 4/r32/esp -34187 # inouts = [var1, var2] -34188 68/push 0/imm32/is-deref:false -34189 56/push-esi/next -34190 68/push 0x11/imm32/alloc-id:fake -34191 51/push-ecx/var1 -34192 68/push 0x11/imm32/alloc-id:fake -34193 68/push 0x11/imm32/alloc-id:fake:payload -34194 89/<- %esi 4/r32/esp -34195 $test-compare-mem-with-reg:initialize-stmt: -34196 # var stmt/esi: (addr statement) -34197 68/push 0/imm32/next -34198 68/push 0/imm32/next -34199 68/push 0/imm32/outputs -34200 68/push 0/imm32/outputs -34201 56/push-esi/inouts -34202 68/push 0x11/imm32/alloc-id:fake -34203 68/push 0/imm32/operation -34204 68/push 0/imm32/operation -34205 68/push 1/imm32/tag:stmt1 -34206 89/<- %esi 4/r32/esp -34207 $test-compare-mem-with-reg:initialize-stmt-operation: -34208 # stmt->operation = "compare" -34209 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -34210 (copy-array Heap "compare" %eax) -34211 # convert -34212 c7 0/subop/copy *Curr-block-depth 0/imm32 -34213 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -34214 (flush _test-output-buffered-file) -34215 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -34221 # check output -34222 (check-next-stream-line-equal _test-output-stream "39/compare-> *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-mem-with-reg") -34223 # . epilogue -34224 89/<- %esp 5/r32/ebp -34225 5d/pop-to-ebp -34226 c3/return -34227 -34228 test-compare-reg-with-mem: -34229 # compare var1/eax, var2 -34230 # => -34231 # 3b/compare<- *(ebp+___) 0/r32/eax -34232 # -34233 # . prologue -34234 55/push-ebp -34235 89/<- %ebp 4/r32/esp -34236 # setup -34237 (clear-stream _test-output-stream) -34238 (clear-stream $_test-output-buffered-file->buffer) -34239 $test-compare-reg-with-mem:initialize-type: -34240 # var type/ecx: (payload type-tree) = int -34241 68/push 0/imm32/right:null -34242 68/push 0/imm32/right:null -34243 68/push 0/imm32/left:unused -34244 68/push 1/imm32/value:int -34245 68/push 1/imm32/is-atom?:true -34246 68/push 0x11/imm32/alloc-id:fake:payload -34247 89/<- %ecx 4/r32/esp -34248 $test-compare-reg-with-mem:initialize-var1: -34249 # var var1/ecx: (payload var) -34250 68/push 0/imm32/register -34251 68/push 0/imm32/register -34252 68/push 0/imm32/no-stack-offset -34253 68/push 1/imm32/block-depth -34254 51/push-ecx -34255 68/push 0x11/imm32/alloc-id:fake -34256 68/push 0/imm32/name -34257 68/push 0/imm32/name -34258 68/push 0x11/imm32/alloc-id:fake:payload -34259 89/<- %ecx 4/r32/esp -34260 $test-compare-reg-with-mem:initialize-var1-name: -34261 # var1->name = "var1" -34262 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -34263 (copy-array Heap "var1" %eax) -34264 $test-compare-reg-with-mem:initialize-var1-register: -34265 # var1->register = "eax" -34266 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -34267 (copy-array Heap "eax" %eax) -34268 $test-compare-reg-with-mem:initialize-var2: -34269 # var var2/edx: (payload var) -34270 68/push 0/imm32/register -34271 68/push 0/imm32/register -34272 68/push 8/imm32/stack-offset -34273 68/push 1/imm32/block-depth -34274 ff 6/subop/push *(ecx+0x10) -34275 68/push 0x11/imm32/alloc-id:fake -34276 68/push 0/imm32/name -34277 68/push 0/imm32/name -34278 68/push 0x11/imm32/alloc-id:fake:payload -34279 89/<- %edx 4/r32/esp -34280 $test-compare-reg-with-mem:initialize-var2-name: -34281 # var2->name = "var2" -34282 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -34283 (copy-array Heap "var2" %eax) -34284 $test-compare-reg-with-mem:initialize-inouts: -34285 # var inouts/esi: (payload stmt-var) = [var2] -34286 68/push 0/imm32/is-deref:false -34287 68/push 0/imm32/next -34288 68/push 0/imm32/next -34289 52/push-edx/var2 -34290 68/push 0x11/imm32/alloc-id:fake -34291 68/push 0x11/imm32/alloc-id:fake:payload -34292 89/<- %esi 4/r32/esp -34293 # inouts = [var1, var2] -34294 68/push 0/imm32/is-deref:false -34295 56/push-esi/next -34296 68/push 0x11/imm32/alloc-id:fake -34297 51/push-ecx/var1 -34298 68/push 0x11/imm32/alloc-id:fake -34299 68/push 0x11/imm32/alloc-id:fake:payload -34300 89/<- %esi 4/r32/esp -34301 $test-compare-reg-with-mem:initialize-stmt: -34302 # var stmt/esi: (addr statement) -34303 68/push 0/imm32/next -34304 68/push 0/imm32/next -34305 68/push 0/imm32/outputs -34306 68/push 0/imm32/outputs -34307 56/push-esi/inouts -34308 68/push 0x11/imm32/alloc-id:fake -34309 68/push 0/imm32/operation -34310 68/push 0/imm32/operation -34311 68/push 1/imm32/tag:stmt1 -34312 89/<- %esi 4/r32/esp -34313 $test-compare-reg-with-mem:initialize-stmt-operation: -34314 # stmt->operation = "compare" -34315 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -34316 (copy-array Heap "compare" %eax) -34317 # convert -34318 c7 0/subop/copy *Curr-block-depth 0/imm32 -34319 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -34320 (flush _test-output-buffered-file) -34321 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -34327 # check output -34328 (check-next-stream-line-equal _test-output-stream "3b/compare<- *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-reg-with-mem") -34329 # . epilogue -34330 89/<- %esp 5/r32/ebp -34331 5d/pop-to-ebp -34332 c3/return -34333 -34334 test-compare-mem-with-literal: -34335 # compare var1, 0x34 -34336 # => -34337 # 81 7/subop/compare *(ebp+___) 0x34/imm32 -34338 # -34339 # . prologue -34340 55/push-ebp -34341 89/<- %ebp 4/r32/esp -34342 # setup -34343 (clear-stream _test-output-stream) -34344 (clear-stream $_test-output-buffered-file->buffer) -34345 $test-compare-mem-with-literal:initialize-type: -34346 # var type/ecx: (payload type-tree) = int -34347 68/push 0/imm32/right:null -34348 68/push 0/imm32/right:null -34349 68/push 0/imm32/left:unused -34350 68/push 1/imm32/value:int -34351 68/push 1/imm32/is-atom?:true -34352 68/push 0x11/imm32/alloc-id:fake:payload -34353 89/<- %ecx 4/r32/esp -34354 $test-compare-mem-with-literal:initialize-var1: -34355 # var var1/ecx: (payload var) -34356 68/push 0/imm32/register -34357 68/push 0/imm32/register -34358 68/push 8/imm32/stack-offset -34359 68/push 1/imm32/block-depth -34360 51/push-ecx -34361 68/push 0x11/imm32/alloc-id:fake -34362 68/push 0/imm32/name -34363 68/push 0/imm32/name -34364 68/push 0x11/imm32/alloc-id:fake:payload -34365 89/<- %ecx 4/r32/esp -34366 $test-compare-mem-with-literal:initialize-var1-name: -34367 # var1->name = "var1" -34368 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -34369 (copy-array Heap "var1" %eax) -34370 $test-compare-mem-with-literal:initialize-literal-type: -34371 # var type/edx: (payload type-tree) = literal -34372 68/push 0/imm32/right:null -34373 68/push 0/imm32/right:null -34374 68/push 0/imm32/left:unused -34375 68/push 0/imm32/value:literal -34376 68/push 1/imm32/is-atom?:true -34377 68/push 0x11/imm32/alloc-id:fake:payload -34378 89/<- %edx 4/r32/esp -34379 $test-compare-mem-with-literal:initialize-literal: -34380 # var l/edx: (payload var) -34381 68/push 0/imm32/register -34382 68/push 0/imm32/register -34383 68/push 0/imm32/no-stack-offset -34384 68/push 1/imm32/block-depth -34385 52/push-edx -34386 68/push 0x11/imm32/alloc-id:fake -34387 68/push 0/imm32/name -34388 68/push 0/imm32/name -34389 68/push 0x11/imm32/alloc-id:fake:payload -34390 89/<- %edx 4/r32/esp -34391 $test-compare-mem-with-literal:initialize-literal-value: -34392 # l->name = "0x34" -34393 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -34394 (copy-array Heap "0x34" %eax) -34395 $test-compare-mem-with-literal:initialize-inouts: -34396 # var inouts/esi: (payload stmt-var) = [l] -34397 68/push 0/imm32/is-deref:false -34398 68/push 0/imm32/next -34399 68/push 0/imm32/next -34400 52/push-edx/l -34401 68/push 0x11/imm32/alloc-id:fake -34402 68/push 0x11/imm32/alloc-id:fake:payload -34403 89/<- %esi 4/r32/esp -34404 # var inouts = (handle stmt-var) = [var1, var2] -34405 68/push 0/imm32/is-deref:false -34406 56/push-esi/next -34407 68/push 0x11/imm32/alloc-id:fake -34408 51/push-ecx/var1 -34409 68/push 0x11/imm32/alloc-id:fake -34410 68/push 0x11/imm32/alloc-id:fake:payload -34411 89/<- %esi 4/r32/esp -34412 $test-compare-mem-with-literal:initialize-stmt: -34413 # var stmt/esi: (addr statement) -34414 68/push 0/imm32/next -34415 68/push 0/imm32/next -34416 68/push 0/imm32/outputs -34417 68/push 0/imm32/outputs -34418 56/push-esi/inouts -34419 68/push 0x11/imm32/alloc-id:fake -34420 68/push 0/imm32/operation -34421 68/push 0/imm32/operation -34422 68/push 1/imm32/tag:stmt1 -34423 89/<- %esi 4/r32/esp -34424 $test-compare-mem-with-literal:initialize-stmt-operation: -34425 # stmt->operation = "compare" -34426 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -34427 (copy-array Heap "compare" %eax) -34428 # convert -34429 c7 0/subop/copy *Curr-block-depth 0/imm32 -34430 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -34431 (flush _test-output-buffered-file) -34432 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -34438 # check output -34439 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare *(ebp+0x00000008) 0x34/imm32" "F - test-compare-mem-with-literal") -34440 # . epilogue -34441 89/<- %esp 5/r32/ebp -34442 5d/pop-to-ebp -34443 c3/return -34444 -34445 test-compare-eax-with-literal: -34446 # compare var1/eax 0x34 -34447 # => -34448 # 3d/compare-eax-with 0x34/imm32 -34449 # -34450 # . prologue -34451 55/push-ebp -34452 89/<- %ebp 4/r32/esp -34453 # setup -34454 (clear-stream _test-output-stream) -34455 (clear-stream $_test-output-buffered-file->buffer) -34456 $test-compare-eax-with-literal:initialize-type: -34457 # var type/ecx: (payload type-tree) = int -34458 68/push 0/imm32/right:null -34459 68/push 0/imm32/right:null -34460 68/push 0/imm32/left:unused -34461 68/push 1/imm32/value:int -34462 68/push 1/imm32/is-atom?:true -34463 68/push 0x11/imm32/alloc-id:fake:payload -34464 89/<- %ecx 4/r32/esp -34465 $test-compare-eax-with-literal:initialize-var1: -34466 # var var1/ecx: (payload var) -34467 68/push 0/imm32/register -34468 68/push 0/imm32/register -34469 68/push 0/imm32/no-stack-offset -34470 68/push 1/imm32/block-depth -34471 51/push-ecx -34472 68/push 0x11/imm32/alloc-id:fake -34473 68/push 0/imm32/name -34474 68/push 0/imm32/name -34475 68/push 0x11/imm32/alloc-id:fake:payload -34476 89/<- %ecx 4/r32/esp -34477 $test-compare-eax-with-literal:initialize-var1-name: -34478 # var1->name = "var1" -34479 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -34480 (copy-array Heap "var1" %eax) -34481 $test-compare-eax-with-literal:initialize-var1-register: -34482 # v->register = "eax" -34483 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -34484 (copy-array Heap "eax" %eax) -34485 $test-compare-eax-with-literal:initialize-literal-type: -34486 # var type/edx: (payload type-tree) = literal -34487 68/push 0/imm32/right:null -34488 68/push 0/imm32/right:null -34489 68/push 0/imm32/left:unused -34490 68/push 0/imm32/value:literal -34491 68/push 1/imm32/is-atom?:true -34492 68/push 0x11/imm32/alloc-id:fake:payload -34493 89/<- %edx 4/r32/esp -34494 $test-compare-eax-with-literal:initialize-literal: -34495 # var l/edx: (payload var) -34496 68/push 0/imm32/register -34497 68/push 0/imm32/register -34498 68/push 0/imm32/no-stack-offset -34499 68/push 1/imm32/block-depth -34500 52/push-edx -34501 68/push 0x11/imm32/alloc-id:fake -34502 68/push 0/imm32/name -34503 68/push 0/imm32/name -34504 68/push 0x11/imm32/alloc-id:fake:payload -34505 89/<- %edx 4/r32/esp -34506 $test-compare-eax-with-literal:initialize-literal-value: -34507 # l->name = "0x34" -34508 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -34509 (copy-array Heap "0x34" %eax) -34510 $test-compare-eax-with-literal:initialize-inouts: -34511 # var inouts/esi: (payload stmt-var) = [l] -34512 68/push 0/imm32/is-deref:false -34513 68/push 0/imm32/next -34514 68/push 0/imm32/next -34515 52/push-edx/l -34516 68/push 0x11/imm32/alloc-id:fake -34517 68/push 0x11/imm32/alloc-id:fake:payload -34518 89/<- %esi 4/r32/esp -34519 # var inouts = (handle stmt-var) = [var1, var2] -34520 68/push 0/imm32/is-deref:false -34521 56/push-esi/next -34522 68/push 0x11/imm32/alloc-id:fake -34523 51/push-ecx/var1 -34524 68/push 0x11/imm32/alloc-id:fake -34525 68/push 0x11/imm32/alloc-id:fake:payload -34526 89/<- %esi 4/r32/esp -34527 $test-compare-eax-with-literal:initialize-stmt: -34528 # var stmt/esi: (addr statement) -34529 68/push 0/imm32/next -34530 68/push 0/imm32/next -34531 68/push 0/imm32/outputs -34532 68/push 0/imm32/outputs -34533 56/push-esi/inouts -34534 68/push 0x11/imm32/alloc-id:fake -34535 68/push 0/imm32/operation -34536 68/push 0/imm32/operation -34537 68/push 1/imm32/tag:stmt1 -34538 89/<- %esi 4/r32/esp -34539 $test-compare-eax-with-literal:initialize-stmt-operation: -34540 # stmt->operation = "compare" -34541 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -34542 (copy-array Heap "compare" %eax) -34543 # convert -34544 c7 0/subop/copy *Curr-block-depth 0/imm32 -34545 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -34546 (flush _test-output-buffered-file) -34547 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -34553 # check output -34554 (check-next-stream-line-equal _test-output-stream "3d/compare-eax-with 0x34/imm32" "F - test-compare-eax-with-literal") -34555 # . epilogue -34556 89/<- %esp 5/r32/ebp -34557 5d/pop-to-ebp -34558 c3/return -34559 -34560 test-compare-reg-with-literal: -34561 # compare var1/ecx 0x34 -34562 # => -34563 # 81 7/subop/compare %ecx 0x34/imm32 -34564 # -34565 # . prologue -34566 55/push-ebp -34567 89/<- %ebp 4/r32/esp -34568 # setup -34569 (clear-stream _test-output-stream) -34570 (clear-stream $_test-output-buffered-file->buffer) -34571 $test-compare-reg-with-literal:initialize-type: -34572 # var type/ecx: (payload type-tree) = int -34573 68/push 0/imm32/right:null -34574 68/push 0/imm32/right:null -34575 68/push 0/imm32/left:unused -34576 68/push 1/imm32/value:int -34577 68/push 1/imm32/is-atom?:true -34578 68/push 0x11/imm32/alloc-id:fake:payload -34579 89/<- %ecx 4/r32/esp -34580 $test-compare-reg-with-literal:initialize-var1: -34581 # var var1/ecx: (payload var) -34582 68/push 0/imm32/register -34583 68/push 0/imm32/register -34584 68/push 0/imm32/no-stack-offset -34585 68/push 1/imm32/block-depth -34586 51/push-ecx -34587 68/push 0x11/imm32/alloc-id:fake -34588 68/push 0/imm32/name -34589 68/push 0/imm32/name -34590 68/push 0x11/imm32/alloc-id:fake:payload -34591 89/<- %ecx 4/r32/esp -34592 $test-compare-reg-with-literal:initialize-var1-name: -34593 # var1->name = "var1" -34594 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -34595 (copy-array Heap "var1" %eax) -34596 $test-compare-reg-with-literal:initialize-var1-register: -34597 # v->register = "ecx" -34598 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 -34599 (copy-array Heap "ecx" %eax) -34600 $test-compare-reg-with-literal:initialize-literal-type: -34601 # var type/edx: (payload type-tree) = literal -34602 68/push 0/imm32/right:null -34603 68/push 0/imm32/right:null -34604 68/push 0/imm32/left:unused -34605 68/push 0/imm32/value:literal -34606 68/push 1/imm32/is-atom?:true -34607 68/push 0x11/imm32/alloc-id:fake:payload -34608 89/<- %edx 4/r32/esp -34609 $test-compare-reg-with-literal:initialize-literal: -34610 # var l/edx: (payload var) -34611 68/push 0/imm32/register -34612 68/push 0/imm32/register -34613 68/push 0/imm32/no-stack-offset -34614 68/push 1/imm32/block-depth -34615 52/push-edx -34616 68/push 0x11/imm32/alloc-id:fake -34617 68/push 0/imm32/name -34618 68/push 0/imm32/name -34619 68/push 0x11/imm32/alloc-id:fake:payload -34620 89/<- %edx 4/r32/esp -34621 $test-compare-reg-with-literal:initialize-literal-value: -34622 # l->name = "0x34" -34623 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 -34624 (copy-array Heap "0x34" %eax) -34625 $test-compare-reg-with-literal:initialize-inouts: -34626 # var inouts/esi: (payload stmt-var) = [l] -34627 68/push 0/imm32/is-deref:false -34628 68/push 0/imm32/next -34629 68/push 0/imm32/next -34630 52/push-edx/l -34631 68/push 0x11/imm32/alloc-id:fake -34632 68/push 0x11/imm32/alloc-id:fake:payload -34633 89/<- %esi 4/r32/esp -34634 # var inouts = (handle stmt-var) = [var1, var2] -34635 68/push 0/imm32/is-deref:false -34636 56/push-esi/next -34637 68/push 0x11/imm32/alloc-id:fake -34638 51/push-ecx/var1 -34639 68/push 0x11/imm32/alloc-id:fake -34640 68/push 0x11/imm32/alloc-id:fake:payload -34641 89/<- %esi 4/r32/esp -34642 $test-compare-reg-with-literal:initialize-stmt: -34643 # var stmt/esi: (addr statement) -34644 68/push 0/imm32/next -34645 68/push 0/imm32/next -34646 68/push 0/imm32/outputs -34647 68/push 0/imm32/outputs -34648 56/push-esi/inouts -34649 68/push 0x11/imm32/alloc-id:fake -34650 68/push 0/imm32/operation -34651 68/push 0/imm32/operation -34652 68/push 1/imm32/tag:stmt1 -34653 89/<- %esi 4/r32/esp -34654 $test-compare-reg-with-literal:initialize-stmt-operation: -34655 # stmt->operation = "compare" -34656 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -34657 (copy-array Heap "compare" %eax) -34658 # convert -34659 c7 0/subop/copy *Curr-block-depth 0/imm32 -34660 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) -34661 (flush _test-output-buffered-file) -34662 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -34668 # check output -34669 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare %ecx 0x34/imm32" "F - test-compare-reg-with-literal") -34670 # . epilogue -34671 89/<- %esp 5/r32/ebp -34672 5d/pop-to-ebp -34673 c3/return -34674 -34675 test-emit-subx-stmt-function-call: -34676 # Call a function on a variable on the stack. -34677 # f foo -34678 # => -34679 # (f *(ebp-8)) -34680 # (Changing the function name supports overloading in general, but here it -34681 # just serves to help disambiguate things.) -34682 # -34683 # There's a variable on the var stack as follows: -34684 # name: 'foo' -34685 # type: int -34686 # stack-offset: -8 -34687 # -34688 # There's nothing in primitives. -34689 # -34690 # We don't perform any checking here on the type of 'f'. -34691 # -34692 # . prologue -34693 55/push-ebp -34694 89/<- %ebp 4/r32/esp -34695 # setup -34696 (clear-stream _test-output-stream) -34697 (clear-stream $_test-output-buffered-file->buffer) -34698 $test-emit-subx-function-call:initialize-type: -34699 # var type/ecx: (payload type-tree) = int -34700 68/push 0/imm32/right:null -34701 68/push 0/imm32/right:null -34702 68/push 0/imm32/left:unused -34703 68/push 1/imm32/value:int -34704 68/push 1/imm32/is-atom?:true -34705 68/push 0x11/imm32/alloc-id:fake:payload -34706 89/<- %ecx 4/r32/esp -34707 $test-emit-subx-function-call:initialize-var: -34708 # var var-foo/ecx: (payload var) = var(type) -34709 68/push 0/imm32/no-register -34710 68/push 0/imm32/no-register -34711 68/push -8/imm32/stack-offset -34712 68/push 1/imm32/block-depth -34713 51/push-ecx/type -34714 68/push 0x11/imm32/alloc-id:fake -34715 68/push 0/imm32/name -34716 68/push 0/imm32/name -34717 68/push 0x11/imm32/alloc-id:fake:payload -34718 89/<- %ecx 4/r32/esp -34719 $test-emit-subx-function-call:initialize-var-name: -34720 # var-foo->name = "foo" -34721 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -34722 (copy-array Heap "foo" %eax) -34723 $test-emit-subx-function-call:initialize-stmt-var: -34724 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) -34725 68/push 0/imm32/is-deref:false -34726 68/push 0/imm32/next -34727 68/push 0/imm32/next -34728 51/push-ecx/var-foo -34729 68/push 0x11/imm32/alloc-id:fake -34730 68/push 0x11/imm32/alloc-id:fake:payload -34731 89/<- %ebx 4/r32/esp -34732 $test-emit-subx-function-call:initialize-stmt: -34733 # var stmt/esi: (addr statement) -34734 68/push 0/imm32/no-outputs -34735 68/push 0/imm32/no-outputs -34736 53/push-ebx/inouts -34737 68/push 0x11/imm32/alloc-id:fake -34738 68/push 0/imm32/operation -34739 68/push 0/imm32/operation -34740 68/push 1/imm32/tag -34741 89/<- %esi 4/r32/esp -34742 $test-emit-subx-function-call:initialize-stmt-operation: -34743 # stmt->operation = "f" -34744 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -34745 (copy-array Heap "f" %eax) -34746 # convert -34747 c7 0/subop/copy *Curr-block-depth 0/imm32 -34748 (emit-subx-stmt _test-output-buffered-file %esi 0 Stderr 0) -34749 (flush _test-output-buffered-file) -34750 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -34756 # check output -34757 (check-next-stream-line-equal _test-output-stream "(f *(ebp+0xfffffff8))" "F - test-emit-subx-stmt-function-call") -34758 # . epilogue -34759 89/<- %esp 5/r32/ebp -34760 5d/pop-to-ebp -34761 c3/return -34762 -34763 test-emit-subx-stmt-function-call-with-literal-arg: -34764 # Call a function on a literal. -34765 # f 0x34 -34766 # => -34767 # (f2 0x34) -34768 # -34769 # . prologue -34770 55/push-ebp -34771 89/<- %ebp 4/r32/esp -34772 # setup -34773 (clear-stream _test-output-stream) -34774 (clear-stream $_test-output-buffered-file->buffer) -34775 $test-emit-subx-function-call-with-literal-arg:initialize-type: -34776 # var type/ecx: (payload type-tree) = int -34777 68/push 0/imm32/right:null -34778 68/push 0/imm32/right:null -34779 68/push 0/imm32/left:unused -34780 68/push 0/imm32/value:literal -34781 68/push 1/imm32/is-atom?:true -34782 68/push 0x11/imm32/alloc-id:fake:payload -34783 89/<- %ecx 4/r32/esp -34784 $test-emit-subx-function-call-with-literal-arg:initialize-var: -34785 # var var-foo/ecx: (payload var) = var(lit) -34786 68/push 0/imm32/no-register -34787 68/push 0/imm32/no-register -34788 68/push 0/imm32/no-stack-offset -34789 68/push 1/imm32/block-depth -34790 51/push-ecx/type -34791 68/push 0x11/imm32/alloc-id:fake -34792 68/push 0/imm32/name -34793 68/push 0/imm32/name -34794 68/push 0x11/imm32/alloc-id:fake:payload -34795 89/<- %ecx 4/r32/esp -34796 $test-emit-subx-function-call-with-literal-arg:initialize-var-name: -34797 # var-foo->name = "0x34" -34798 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 -34799 (copy-array Heap "0x34" %eax) -34800 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-var: -34801 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) -34802 68/push 0/imm32/is-deref:false -34803 68/push 0/imm32/next -34804 68/push 0/imm32/next -34805 51/push-ecx/var-foo -34806 68/push 0x11/imm32/alloc-id:fake -34807 68/push 0x11/imm32/alloc-id:fake:payload -34808 89/<- %ebx 4/r32/esp -34809 $test-emit-subx-function-call-with-literal-arg:initialize-stmt: -34810 # var stmt/esi: (addr statement) -34811 68/push 0/imm32/no-outputs -34812 68/push 0/imm32/no-outputs -34813 53/push-ebx/inouts -34814 68/push 0x11/imm32/alloc-id:fake -34815 68/push 0/imm32/operation -34816 68/push 0/imm32/operation -34817 68/push 1/imm32/tag -34818 89/<- %esi 4/r32/esp -34819 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-operation: -34820 # stmt->operation = "f" -34821 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation -34822 (copy-array Heap "f" %eax) -34823 # convert -34824 c7 0/subop/copy *Curr-block-depth 0/imm32 -34825 (emit-subx-stmt _test-output-buffered-file %esi 0 %ebx Stderr 0) -34826 (flush _test-output-buffered-file) -34827 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- -34833 # check output -34834 (check-next-stream-line-equal _test-output-stream "(f 0x34)" "F - test-emit-subx-stmt-function-call-with-literal-arg") -34835 # . epilogue -34836 89/<- %esp 5/r32/ebp -34837 5d/pop-to-ebp -34838 c3/return -34839 -34840 emit-indent: # out: (addr buffered-file), n: int -34841 # . prologue -34842 55/push-ebp -34843 89/<- %ebp 4/r32/esp -34844 # . save registers -34845 50/push-eax -34846 # var i/eax: int = n -34847 8b/-> *(ebp+0xc) 0/r32/eax -34848 { -34849 # if (i <= 0) break -34850 3d/compare-eax-with 0/imm32 -34851 7e/jump-if-<= break/disp8 -34852 (write-buffered *(ebp+8) " ") -34853 48/decrement-eax -34854 eb/jump loop/disp8 -34855 } -34856 $emit-indent:end: -34857 # . restore registers -34858 58/pop-to-eax -34859 # . epilogue -34860 89/<- %esp 5/r32/ebp -34861 5d/pop-to-ebp -34862 c3/return -34863 -34864 emit-subx-prologue: # out: (addr buffered-file) -34865 # . prologue -34866 55/push-ebp -34867 89/<- %ebp 4/r32/esp -34868 # -34869 (write-buffered *(ebp+8) " # . prologue\n") -34870 (write-buffered *(ebp+8) " 55/push-ebp\n") -34871 (write-buffered *(ebp+8) " 89/<- %ebp 4/r32/esp\n") -34872 $emit-subx-prologue:end: -34873 # . epilogue -34874 89/<- %esp 5/r32/ebp -34875 5d/pop-to-ebp -34876 c3/return -34877 -34878 emit-subx-epilogue: # out: (addr buffered-file) -34879 # . prologue -34880 55/push-ebp -34881 89/<- %ebp 4/r32/esp -34882 # -34883 (write-buffered *(ebp+8) " # . epilogue\n") -34884 (write-buffered *(ebp+8) " 89/<- %esp 5/r32/ebp\n") -34885 (write-buffered *(ebp+8) " 5d/pop-to-ebp\n") -34886 (write-buffered *(ebp+8) " c3/return\n") -34887 $emit-subx-epilogue:end: -34888 # . epilogue -34889 89/<- %esp 5/r32/ebp -34890 5d/pop-to-ebp -34891 c3/return +33982 53/push-ebx/formal-var +33983 68/push 0x11/imm32/alloc-id:fake +33984 68/push 0x11/imm32/alloc-id:fake:payload +33985 89/<- %ebx 4/r32/esp +33986 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2: +33987 # var primitive2/edi: (payload primitive) +33988 68/push 0/imm32/next +33989 68/push 0/imm32/next +33990 68/push 0/imm32/no-x32 +33991 68/push 0/imm32/no-xm32 +33992 68/push 0/imm32/no-disp32 +33993 68/push 0/imm32/no-imm8 +33994 68/push 0/imm32/no-imm32 +33995 68/push 0/imm32/no-r32 +33996 68/push 3/imm32/rm32-is-first-output +33997 68/push 0/imm32/subx-name +33998 68/push 0/imm32/subx-name +33999 53/push-ebx/outputs +34000 68/push 0x11/imm32/alloc-id:fake +34001 68/push 0/imm32/no-inouts +34002 68/push 0/imm32/no-inouts +34003 68/push 0/imm32/name +34004 68/push 0/imm32/name +34005 68/push 0x11/imm32/alloc-id:fake:payload +34006 89/<- %edi 4/r32/esp +34007 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-name: +34008 # primitives->name = "increment" +34009 8d/copy-address *(edi+4) 0/r32/eax # Primitive-name + 4 +34010 (copy-array Heap "increment" %eax) +34011 $test-emit-subx-stmt-select-primitive-2:initialize-primitive2-subx-name: +34012 # primitives->subx-name = "ff 0/subop/increment" +34013 8d/copy-address *(edi+0x1c) 0/r32/eax # Primitive-subx-name + 4 +34014 (copy-array Heap "ff 0/subop/increment" %eax) +34015 $test-emit-subx-stmt-select-primitive-2:initialize-primitive: +34016 # var primitives/ebx: (addr primitive) +34017 57/push-edi +34018 68/push 0x11/imm32/alloc-id:fake +34019 68/push 0/imm32/no-x32 +34020 68/push 0/imm32/no-xm32 +34021 68/push 0/imm32/no-disp32 +34022 68/push 0/imm32/no-imm8 +34023 68/push 0/imm32/no-imm32 +34024 68/push 0/imm32/no-r32 +34025 68/push 1/imm32/rm32-is-first-inout +34026 68/push 0/imm32/subx-name +34027 68/push 0/imm32/subx-name +34028 68/push 0/imm32/no-outputs +34029 68/push 0/imm32/no-outputs +34030 53/push-ebx/inouts # hack: reuse stmt-var from call stmt as (list var) in function declaration +34031 68/push 0x11/imm32/alloc-id:fake +34032 68/push 0/imm32/name +34033 68/push 0/imm32/name +34034 89/<- %ebx 4/r32/esp +34035 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-name: +34036 # primitives->name = "increment" +34037 (copy-array Heap "increment" %ebx) # Primitive-name +34038 $test-emit-subx-stmt-select-primitive-2:initialize-primitive-subx-name: +34039 # primitives->subx-name = "ff 0/subop/increment" +34040 8d/copy-address *(ebx+0x18) 0/r32/eax # Primitive-subx-name +34041 (copy-array Heap "ff 0/subop/increment" %eax) +34042 # convert +34043 c7 0/subop/copy *Curr-block-depth 0/imm32 +34044 (emit-subx-stmt _test-output-buffered-file %esi %ebx Stderr 0) +34045 (flush _test-output-buffered-file) +34046 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +34052 # check output +34053 (check-next-stream-line-equal _test-output-stream "ff 0/subop/increment %eax" "F - test-emit-subx-stmt-select-primitive-2") +34054 # . epilogue +34055 89/<- %esp 5/r32/ebp +34056 5d/pop-to-ebp +34057 c3/return +34058 +34059 test-increment-register: +34060 # Select the right register between overloads. +34061 # foo <- increment +34062 # => +34063 # 50/increment-eax +34064 # +34065 # There's a variable on the var stack as follows: +34066 # name: 'foo' +34067 # type: int +34068 # register: 'eax' +34069 # +34070 # Primitives are the global definitions. +34071 # +34072 # . prologue +34073 55/push-ebp +34074 89/<- %ebp 4/r32/esp +34075 # setup +34076 (clear-stream _test-output-stream) +34077 (clear-stream $_test-output-buffered-file->buffer) +34078 $test-increment-register:initialize-type: +34079 # var type/ecx: (payload type-tree) = int +34080 68/push 0/imm32/right:null +34081 68/push 0/imm32/right:null +34082 68/push 0/imm32/left:unused +34083 68/push 1/imm32/value:int +34084 68/push 1/imm32/is-atom?:true +34085 68/push 0x11/imm32/alloc-id:fake:payload +34086 89/<- %ecx 4/r32/esp +34087 $test-increment-register:initialize-var: +34088 # var var-foo/ecx: (payload var) +34089 68/push 0/imm32/register +34090 68/push 0/imm32/register +34091 68/push 0/imm32/no-stack-offset +34092 68/push 1/imm32/block-depth +34093 51/push-ecx +34094 68/push 0x11/imm32/alloc-id:fake +34095 68/push 0/imm32/name +34096 68/push 0/imm32/name +34097 68/push 0x11/imm32/alloc-id:fake:payload +34098 89/<- %ecx 4/r32/esp +34099 $test-increment-register:initialize-var-name: +34100 # var-foo->name = "foo" +34101 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +34102 (copy-array Heap "foo" %eax) +34103 $test-increment-register:initialize-var-register: +34104 # var-foo->register = "eax" +34105 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +34106 (copy-array Heap "eax" %eax) +34107 $test-increment-register:initialize-stmt-var: +34108 # var operand/ebx: (payload stmt-var) +34109 68/push 0/imm32/is-deref:false +34110 68/push 0/imm32/next +34111 68/push 0/imm32/next +34112 51/push-ecx/var-foo +34113 68/push 0x11/imm32/alloc-id:fake +34114 68/push 0x11/imm32/alloc-id:fake:payload +34115 89/<- %ebx 4/r32/esp +34116 $test-increment-register:initialize-stmt: +34117 # var stmt/esi: (addr statement) +34118 53/push-ebx/outputs +34119 68/push 0x11/imm32/alloc-id:fake +34120 68/push 0/imm32/no-inouts +34121 68/push 0/imm32/no-inouts +34122 68/push 0/imm32/operation +34123 68/push 0/imm32/operation +34124 68/push 1/imm32 +34125 89/<- %esi 4/r32/esp +34126 $test-increment-register:initialize-stmt-operation: +34127 # stmt->operation = "increment" +34128 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +34129 (copy-array Heap "increment" %eax) +34130 # convert +34131 c7 0/subop/copy *Curr-block-depth 0/imm32 +34132 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +34133 (flush _test-output-buffered-file) +34134 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +34140 # check output +34141 (check-next-stream-line-equal _test-output-stream "40/increment-eax" "F - test-increment-register") +34142 # . epilogue +34143 89/<- %esp 5/r32/ebp +34144 5d/pop-to-ebp +34145 c3/return +34146 +34147 test-add-reg-to-reg: +34148 # var1/reg <- add var2/reg +34149 # => +34150 # 01/add-to %var1 var2 +34151 # +34152 # . prologue +34153 55/push-ebp +34154 89/<- %ebp 4/r32/esp +34155 # setup +34156 (clear-stream _test-output-stream) +34157 (clear-stream $_test-output-buffered-file->buffer) +34158 $test-add-reg-to-reg:initialize-type: +34159 # var type/ecx: (payload type-tree) = int +34160 68/push 0/imm32/right:null +34161 68/push 0/imm32/right:null +34162 68/push 0/imm32/left:unused +34163 68/push 1/imm32/value:int +34164 68/push 1/imm32/is-atom?:true +34165 68/push 0x11/imm32/alloc-id:fake:payload +34166 89/<- %ecx 4/r32/esp +34167 $test-add-reg-to-reg:initialize-var1: +34168 # var var1/ecx: (payload var) +34169 68/push 0/imm32/register +34170 68/push 0/imm32/register +34171 68/push 0/imm32/no-stack-offset +34172 68/push 1/imm32/block-depth +34173 51/push-ecx +34174 68/push 0x11/imm32/alloc-id:fake +34175 68/push 0/imm32/name +34176 68/push 0/imm32/name +34177 68/push 0x11/imm32/alloc-id:fake:payload +34178 89/<- %ecx 4/r32/esp +34179 $test-add-reg-to-reg:initialize-var1-name: +34180 # var1->name = "var1" +34181 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +34182 (copy-array Heap "var1" %eax) +34183 $test-add-reg-to-reg:initialize-var1-register: +34184 # var1->register = "eax" +34185 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +34186 (copy-array Heap "eax" %eax) +34187 $test-add-reg-to-reg:initialize-var2: +34188 # var var2/edx: (payload var) +34189 68/push 0/imm32/register +34190 68/push 0/imm32/register +34191 68/push 0/imm32/no-stack-offset +34192 68/push 1/imm32/block-depth +34193 ff 6/subop/push *(ecx+0x10) +34194 68/push 0x11/imm32/alloc-id:fake +34195 68/push 0/imm32/name +34196 68/push 0/imm32/name +34197 68/push 0x11/imm32/alloc-id:fake:payload +34198 89/<- %edx 4/r32/esp +34199 $test-add-reg-to-reg:initialize-var2-name: +34200 # var2->name = "var2" +34201 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +34202 (copy-array Heap "var2" %eax) +34203 $test-add-reg-to-reg:initialize-var2-register: +34204 # var2->register = "ecx" +34205 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +34206 (copy-array Heap "ecx" %eax) +34207 $test-add-reg-to-reg:initialize-inouts: +34208 # var inouts/esi: (payload stmt-var) = [var2] +34209 68/push 0/imm32/is-deref:false +34210 68/push 0/imm32/next +34211 68/push 0/imm32/next +34212 52/push-edx/var2 +34213 68/push 0x11/imm32/alloc-id:fake +34214 68/push 0x11/imm32/alloc-id:fake:payload +34215 89/<- %esi 4/r32/esp +34216 $test-add-reg-to-reg:initialize-outputs: +34217 # var outputs/edi: (payload stmt-var) = [var1] +34218 68/push 0/imm32/is-deref:false +34219 68/push 0/imm32/next +34220 68/push 0/imm32/next +34221 51/push-ecx/var1 +34222 68/push 0x11/imm32/alloc-id:fake +34223 68/push 0x11/imm32/alloc-id:fake:payload +34224 89/<- %edi 4/r32/esp +34225 $test-add-reg-to-reg:initialize-stmt: +34226 # var stmt/esi: (addr statement) +34227 68/push 0/imm32/next +34228 68/push 0/imm32/next +34229 57/push-edi/outputs +34230 68/push 0x11/imm32/alloc-id:fake +34231 56/push-esi/inouts +34232 68/push 0x11/imm32/alloc-id:fake +34233 68/push 0/imm32/operation +34234 68/push 0/imm32/operation +34235 68/push 1/imm32/tag:stmt1 +34236 89/<- %esi 4/r32/esp +34237 $test-add-reg-to-reg:initialize-stmt-operation: +34238 # stmt->operation = "add" +34239 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +34240 (copy-array Heap "add" %eax) +34241 # convert +34242 c7 0/subop/copy *Curr-block-depth 0/imm32 +34243 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +34244 (flush _test-output-buffered-file) +34245 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +34251 # check output +34252 (check-next-stream-line-equal _test-output-stream "01/add-to %eax 0x00000001/r32" "F - test-add-reg-to-reg") +34253 # . epilogue +34254 89/<- %esp 5/r32/ebp +34255 5d/pop-to-ebp +34256 c3/return +34257 +34258 test-add-reg-to-mem: +34259 # add-to var1 var2/reg +34260 # => +34261 # 01/add-to *(ebp+__) var2 +34262 # +34263 # . prologue +34264 55/push-ebp +34265 89/<- %ebp 4/r32/esp +34266 # setup +34267 (clear-stream _test-output-stream) +34268 (clear-stream $_test-output-buffered-file->buffer) +34269 $test-add-reg-to-mem:initialize-type: +34270 # var type/ecx: (payload type-tree) = int +34271 68/push 0/imm32/right:null +34272 68/push 0/imm32/right:null +34273 68/push 0/imm32/left:unused +34274 68/push 1/imm32/value:int +34275 68/push 1/imm32/is-atom?:true +34276 68/push 0x11/imm32/alloc-id:fake:payload +34277 89/<- %ecx 4/r32/esp +34278 $test-add-reg-to-mem:initialize-var1: +34279 # var var1/ecx: (payload var) +34280 68/push 0/imm32/register +34281 68/push 0/imm32/register +34282 68/push 8/imm32/stack-offset +34283 68/push 1/imm32/block-depth +34284 51/push-ecx +34285 68/push 0x11/imm32/alloc-id:fake +34286 68/push 0/imm32/name +34287 68/push 0/imm32/name +34288 68/push 0x11/imm32/alloc-id:fake:payload +34289 89/<- %ecx 4/r32/esp +34290 $test-add-reg-to-mem:initialize-var1-name: +34291 # var1->name = "var1" +34292 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +34293 (copy-array Heap "var1" %eax) +34294 $test-add-reg-to-mem:initialize-var2: +34295 # var var2/edx: (payload var) +34296 68/push 0/imm32/register +34297 68/push 0/imm32/register +34298 68/push 0/imm32/no-stack-offset +34299 68/push 1/imm32/block-depth +34300 ff 6/subop/push *(ecx+0x10) +34301 68/push 0x11/imm32/alloc-id:fake +34302 68/push 0/imm32/name +34303 68/push 0/imm32/name +34304 68/push 0x11/imm32/alloc-id:fake:payload +34305 89/<- %edx 4/r32/esp +34306 $test-add-reg-to-mem:initialize-var2-name: +34307 # var2->name = "var2" +34308 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +34309 (copy-array Heap "var2" %eax) +34310 $test-add-reg-to-mem:initialize-var2-register: +34311 # var2->register = "ecx" +34312 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +34313 (copy-array Heap "ecx" %eax) +34314 $test-add-reg-to-mem:initialize-inouts: +34315 # var inouts/esi: (payload stmt-var) = [var2] +34316 68/push 0/imm32/is-deref:false +34317 68/push 0/imm32/next +34318 68/push 0/imm32/next +34319 52/push-edx/var2 +34320 68/push 0x11/imm32/alloc-id:fake +34321 68/push 0x11/imm32/alloc-id:fake:payload +34322 89/<- %esi 4/r32/esp +34323 # inouts = [var1, var2] +34324 68/push 0/imm32/is-deref:false +34325 56/push-esi/next +34326 68/push 0x11/imm32/alloc-id:fake +34327 51/push-ecx/var1 +34328 68/push 0x11/imm32/alloc-id:fake +34329 68/push 0x11/imm32/alloc-id:fake:payload +34330 89/<- %esi 4/r32/esp +34331 $test-add-reg-to-mem:initialize-stmt: +34332 # var stmt/esi: (addr statement) +34333 68/push 0/imm32/next +34334 68/push 0/imm32/next +34335 68/push 0/imm32/outputs +34336 68/push 0/imm32/outputs +34337 56/push-esi/inouts +34338 68/push 0x11/imm32/alloc-id:fake +34339 68/push 0/imm32/operation +34340 68/push 0/imm32/operation +34341 68/push 1/imm32/tag:stmt1 +34342 89/<- %esi 4/r32/esp +34343 $test-add-reg-to-mem:initialize-stmt-operation: +34344 # stmt->operation = "add-to" +34345 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +34346 (copy-array Heap "add-to" %eax) +34347 # convert +34348 c7 0/subop/copy *Curr-block-depth 0/imm32 +34349 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +34350 (flush _test-output-buffered-file) +34351 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +34357 # check output +34358 (check-next-stream-line-equal _test-output-stream "01/add-to *(ebp+0x00000008) 0x00000001/r32" "F - test-add-reg-to-mem") +34359 # . epilogue +34360 89/<- %esp 5/r32/ebp +34361 5d/pop-to-ebp +34362 c3/return +34363 +34364 test-add-mem-to-reg: +34365 # var1/reg <- add var2 +34366 # => +34367 # 03/add *(ebp+__) var1 +34368 # +34369 # . prologue +34370 55/push-ebp +34371 89/<- %ebp 4/r32/esp +34372 # setup +34373 (clear-stream _test-output-stream) +34374 (clear-stream $_test-output-buffered-file->buffer) +34375 $test-add-mem-to-reg:initialize-type: +34376 # var type/ecx: (payload type-tree) = int +34377 68/push 0/imm32/right:null +34378 68/push 0/imm32/right:null +34379 68/push 0/imm32/left:unused +34380 68/push 1/imm32/value:int +34381 68/push 1/imm32/is-atom?:true +34382 68/push 0x11/imm32/alloc-id:fake:payload +34383 89/<- %ecx 4/r32/esp +34384 $test-add-mem-to-reg:initialize-var: +34385 # var var1/ecx: (payload var) +34386 68/push 0/imm32/register +34387 68/push 0/imm32/register +34388 68/push 0/imm32/no-stack-offset +34389 68/push 1/imm32/block-depth +34390 51/push-ecx +34391 68/push 0x11/imm32/alloc-id:fake +34392 68/push 0/imm32/name +34393 68/push 0/imm32/name +34394 68/push 0x11/imm32/alloc-id:fake:payload +34395 89/<- %ecx 4/r32/esp +34396 $test-add-mem-to-reg:initialize-var-name: +34397 # var1->name = "foo" +34398 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +34399 (copy-array Heap "var1" %eax) +34400 $test-add-mem-to-reg:initialize-var-register: +34401 # var1->register = "eax" +34402 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +34403 (copy-array Heap "eax" %eax) +34404 $test-add-mem-to-reg:initialize-var2: +34405 # var var2/edx: (payload var) +34406 68/push 0/imm32/register +34407 68/push 0/imm32/register +34408 68/push 8/imm32/stack-offset +34409 68/push 1/imm32/block-depth +34410 ff 6/subop/push *(ecx+0x10) +34411 68/push 0x11/imm32/alloc-id:fake +34412 68/push 0/imm32/name +34413 68/push 0/imm32/name +34414 68/push 0x11/imm32/alloc-id:fake:payload +34415 89/<- %edx 4/r32/esp +34416 $test-add-mem-to-reg:initialize-var2-name: +34417 # var2->name = "var2" +34418 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +34419 (copy-array Heap "var2" %eax) +34420 $test-add-mem-to-reg:initialize-inouts: +34421 # var inouts/esi: (payload stmt-var) = [var2] +34422 68/push 0/imm32/is-deref:false +34423 68/push 0/imm32/next +34424 68/push 0/imm32/next +34425 52/push-edx/var2 +34426 68/push 0x11/imm32/alloc-id:fake +34427 68/push 0x11/imm32/alloc-id:fake:payload +34428 89/<- %esi 4/r32/esp +34429 $test-add-mem-to-reg:initialize-outputs: +34430 # var outputs/edi: (payload stmt-var) = [var1] +34431 68/push 0/imm32/is-deref:false +34432 68/push 0/imm32/next +34433 68/push 0/imm32/next +34434 51/push-ecx/var1 +34435 68/push 0x11/imm32/alloc-id:fake +34436 68/push 0x11/imm32/alloc-id:fake:payload +34437 89/<- %edi 4/r32/esp +34438 $test-add-mem-to-reg:initialize-stmt: +34439 # var stmt/esi: (addr statement) +34440 68/push 0/imm32/next +34441 68/push 0/imm32/next +34442 57/push-edi/outputs +34443 68/push 0x11/imm32/alloc-id:fake +34444 56/push-esi/inouts +34445 68/push 0x11/imm32/alloc-id:fake +34446 68/push 0/imm32/operation +34447 68/push 0/imm32/operation +34448 68/push 1/imm32/tag:stmt1 +34449 89/<- %esi 4/r32/esp +34450 $test-add-mem-to-reg:initialize-stmt-operation: +34451 # stmt->operation = "add" +34452 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +34453 (copy-array Heap "add" %eax) +34454 # convert +34455 c7 0/subop/copy *Curr-block-depth 0/imm32 +34456 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +34457 (flush _test-output-buffered-file) +34458 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +34464 # check output +34465 (check-next-stream-line-equal _test-output-stream "03/add *(ebp+0x00000008) 0x00000000/r32" "F - test-add-mem-to-reg") +34466 # . epilogue +34467 89/<- %esp 5/r32/ebp +34468 5d/pop-to-ebp +34469 c3/return +34470 +34471 test-add-literal-to-eax: +34472 # var1/eax <- add 0x34 +34473 # => +34474 # 05/add-to-eax 0x34/imm32 +34475 # +34476 # . prologue +34477 55/push-ebp +34478 89/<- %ebp 4/r32/esp +34479 # setup +34480 (clear-stream _test-output-stream) +34481 (clear-stream $_test-output-buffered-file->buffer) +34482 $test-add-literal-to-eax:initialize-var-type: +34483 # var type/ecx: (payload type-tree) = int +34484 68/push 0/imm32/right:null +34485 68/push 0/imm32/right:null +34486 68/push 0/imm32/left:unused +34487 68/push 1/imm32/value:int +34488 68/push 1/imm32/is-atom?:true +34489 68/push 0x11/imm32/alloc-id:fake:payload +34490 89/<- %ecx 4/r32/esp +34491 $test-add-literal-to-eax:initialize-var: +34492 # var v/ecx: (payload var) +34493 68/push 0/imm32/register +34494 68/push 0/imm32/register +34495 68/push 0/imm32/no-stack-offset +34496 68/push 1/imm32/block-depth +34497 51/push-ecx +34498 68/push 0x11/imm32/alloc-id:fake +34499 68/push 0/imm32/name +34500 68/push 0/imm32/name +34501 68/push 0x11/imm32/alloc-id:fake:payload +34502 89/<- %ecx 4/r32/esp +34503 $test-add-literal-to-eax:initialize-var-name: +34504 # v->name = "v" +34505 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +34506 (copy-array Heap "v" %eax) +34507 $test-add-literal-to-eax:initialize-var-register: +34508 # v->register = "eax" +34509 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +34510 (copy-array Heap "eax" %eax) +34511 $test-add-literal-to-eax:initialize-literal-type: +34512 # var type/edx: (payload type-tree) = literal +34513 68/push 0/imm32/right:null +34514 68/push 0/imm32/right:null +34515 68/push 0/imm32/left:unused +34516 68/push 0/imm32/value:literal +34517 68/push 1/imm32/is-atom?:true +34518 68/push 0x11/imm32/alloc-id:fake:payload +34519 89/<- %edx 4/r32/esp +34520 $test-add-literal-to-eax:initialize-literal: +34521 # var l/edx: (payload var) +34522 68/push 0/imm32/register +34523 68/push 0/imm32/register +34524 68/push 0/imm32/no-stack-offset +34525 68/push 1/imm32/block-depth +34526 52/push-edx +34527 68/push 0x11/imm32/alloc-id:fake +34528 68/push 0/imm32/name +34529 68/push 0/imm32/name +34530 68/push 0x11/imm32/alloc-id:fake:payload +34531 89/<- %edx 4/r32/esp +34532 $test-add-literal-to-eax:initialize-literal-value: +34533 # l->name = "0x34" +34534 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +34535 (copy-array Heap "0x34" %eax) +34536 $test-add-literal-to-eax:initialize-inouts: +34537 # var inouts/esi: (payload stmt-var) = [l] +34538 68/push 0/imm32/is-deref:false +34539 68/push 0/imm32/next +34540 68/push 0/imm32/next +34541 52/push-edx/l +34542 68/push 0x11/imm32/alloc-id:fake +34543 68/push 0x11/imm32/alloc-id:fake:payload +34544 89/<- %esi 4/r32/esp +34545 $test-add-literal-to-eax:initialize-outputs: +34546 # var outputs/edi: (payload stmt-var) = [v] +34547 68/push 0/imm32/is-deref:false +34548 68/push 0/imm32/next +34549 68/push 0/imm32/next +34550 51/push-ecx/v +34551 68/push 0x11/imm32/alloc-id:fake +34552 68/push 0x11/imm32/alloc-id:fake:payload +34553 89/<- %edi 4/r32/esp +34554 $test-add-literal-to-eax:initialize-stmt: +34555 # var stmt/esi: (addr statement) +34556 68/push 0/imm32/next +34557 68/push 0/imm32/next +34558 57/push-edi/outputs +34559 68/push 0x11/imm32/alloc-id:fake +34560 56/push-esi/inouts +34561 68/push 0x11/imm32/alloc-id:fake +34562 68/push 0/imm32/operation +34563 68/push 0/imm32/operation +34564 68/push 1/imm32/tag:stmt1 +34565 89/<- %esi 4/r32/esp +34566 $test-add-literal-to-eax:initialize-stmt-operation: +34567 # stmt->operation = "add" +34568 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +34569 (copy-array Heap "add" %eax) +34570 # convert +34571 c7 0/subop/copy *Curr-block-depth 0/imm32 +34572 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +34573 (flush _test-output-buffered-file) +34574 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +34580 # check output +34581 (check-next-stream-line-equal _test-output-stream "05/add-to-eax 0x34/imm32" "F - test-add-literal-to-eax") +34582 # . epilogue +34583 89/<- %esp 5/r32/ebp +34584 5d/pop-to-ebp +34585 c3/return +34586 +34587 test-add-literal-to-reg: +34588 # var1/ecx <- add 0x34 +34589 # => +34590 # 81 0/subop/add %ecx 0x34/imm32 +34591 # +34592 # . prologue +34593 55/push-ebp +34594 89/<- %ebp 4/r32/esp +34595 # setup +34596 (clear-stream _test-output-stream) +34597 (clear-stream $_test-output-buffered-file->buffer) +34598 $test-add-literal-to-reg:initialize-var-type: +34599 # var type/ecx: (payload type-tree) = int +34600 68/push 0/imm32/right:null +34601 68/push 0/imm32/right:null +34602 68/push 0/imm32/left:unused +34603 68/push 1/imm32/value:int +34604 68/push 1/imm32/is-atom?:true +34605 68/push 0x11/imm32/alloc-id:fake:payload +34606 89/<- %ecx 4/r32/esp +34607 $test-add-literal-to-reg:initialize-var: +34608 # var v/ecx: (payload var) +34609 68/push 0/imm32/register +34610 68/push 0/imm32/register +34611 68/push 0/imm32/no-stack-offset +34612 68/push 1/imm32/block-depth +34613 51/push-ecx +34614 68/push 0x11/imm32/alloc-id:fake +34615 68/push 0/imm32/name +34616 68/push 0/imm32/name +34617 68/push 0x11/imm32/alloc-id:fake:payload +34618 89/<- %ecx 4/r32/esp +34619 $test-add-literal-to-reg:initialize-var-name: +34620 # v->name = "v" +34621 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +34622 (copy-array Heap "v" %eax) +34623 $test-add-literal-to-reg:initialize-var-register: +34624 # v->register = "ecx" +34625 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +34626 (copy-array Heap "ecx" %eax) +34627 $test-add-literal-to-reg:initialize-literal-type: +34628 # var type/edx: (payload type-tree) = literal +34629 68/push 0/imm32/right:null +34630 68/push 0/imm32/right:null +34631 68/push 0/imm32/left:unused +34632 68/push 0/imm32/value:literal +34633 68/push 1/imm32/is-atom?:true +34634 68/push 0x11/imm32/alloc-id:fake:payload +34635 89/<- %edx 4/r32/esp +34636 $test-add-literal-to-reg:initialize-literal: +34637 # var l/edx: (payload var) +34638 68/push 0/imm32/register +34639 68/push 0/imm32/register +34640 68/push 0/imm32/no-stack-offset +34641 68/push 1/imm32/block-depth +34642 52/push-edx +34643 68/push 0x11/imm32/alloc-id:fake +34644 68/push 0/imm32/name +34645 68/push 0/imm32/name +34646 68/push 0x11/imm32/alloc-id:fake:payload +34647 89/<- %edx 4/r32/esp +34648 $test-add-literal-to-reg:initialize-literal-value: +34649 # l->name = "0x34" +34650 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +34651 (copy-array Heap "0x34" %eax) +34652 $test-add-literal-to-reg:initialize-inouts: +34653 # var inouts/esi: (payload stmt-var) = [l] +34654 68/push 0/imm32/is-deref:false +34655 68/push 0/imm32/next +34656 68/push 0/imm32/next +34657 52/push-edx/l +34658 68/push 0x11/imm32/alloc-id:fake +34659 68/push 0x11/imm32/alloc-id:fake:payload +34660 89/<- %esi 4/r32/esp +34661 $test-add-literal-to-reg:initialize-outputs: +34662 # var outputs/edi: (payload stmt-var) = [v] +34663 68/push 0/imm32/is-deref:false +34664 68/push 0/imm32/next +34665 68/push 0/imm32/next +34666 51/push-ecx/v +34667 68/push 0x11/imm32/alloc-id:fake +34668 68/push 0x11/imm32/alloc-id:fake:payload +34669 89/<- %edi 4/r32/esp +34670 $test-add-literal-to-reg:initialize-stmt: +34671 # var stmt/esi: (addr statement) +34672 68/push 0/imm32/next +34673 68/push 0/imm32/next +34674 57/push-edi/outputs +34675 68/push 0x11/imm32/alloc-id:fake +34676 56/push-esi/inouts +34677 68/push 0x11/imm32/alloc-id:fake +34678 68/push 0/imm32/operation +34679 68/push 0/imm32/operation +34680 68/push 1/imm32/tag:stmt1 +34681 89/<- %esi 4/r32/esp +34682 $test-add-literal-to-reg:initialize-stmt-operation: +34683 # stmt->operation = "add" +34684 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +34685 (copy-array Heap "add" %eax) +34686 # convert +34687 c7 0/subop/copy *Curr-block-depth 0/imm32 +34688 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +34689 (flush _test-output-buffered-file) +34690 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +34696 # check output +34697 (check-next-stream-line-equal _test-output-stream "81 0/subop/add %ecx 0x34/imm32" "F - test-add-literal-to-reg") +34698 # . epilogue +34699 89/<- %esp 5/r32/ebp +34700 5d/pop-to-ebp +34701 c3/return +34702 +34703 test-add-literal-to-mem: +34704 # add-to var1, 0x34 +34705 # => +34706 # 81 0/subop/add %eax 0x34/imm32 +34707 # +34708 # . prologue +34709 55/push-ebp +34710 89/<- %ebp 4/r32/esp +34711 # setup +34712 (clear-stream _test-output-stream) +34713 (clear-stream $_test-output-buffered-file->buffer) +34714 $test-add-literal-to-mem:initialize-type: +34715 # var type/ecx: (payload type-tree) = int +34716 68/push 0/imm32/right:null +34717 68/push 0/imm32/right:null +34718 68/push 0/imm32/left:unused +34719 68/push 1/imm32/value:int +34720 68/push 1/imm32/is-atom?:true +34721 68/push 0x11/imm32/alloc-id:fake:payload +34722 89/<- %ecx 4/r32/esp +34723 $test-add-literal-to-mem:initialize-var1: +34724 # var var1/ecx: (payload var) +34725 68/push 0/imm32/register +34726 68/push 0/imm32/register +34727 68/push 8/imm32/stack-offset +34728 68/push 1/imm32/block-depth +34729 51/push-ecx +34730 68/push 0x11/imm32/alloc-id:fake +34731 68/push 0/imm32/name +34732 68/push 0/imm32/name +34733 68/push 0x11/imm32/alloc-id:fake:payload +34734 89/<- %ecx 4/r32/esp +34735 $test-add-literal-to-mem:initialize-var1-name: +34736 # var1->name = "var1" +34737 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +34738 (copy-array Heap "var1" %eax) +34739 $test-add-literal-to-mem:initialize-literal-type: +34740 # var type/edx: (payload type-tree) = literal +34741 68/push 0/imm32/right:null +34742 68/push 0/imm32/right:null +34743 68/push 0/imm32/left:unused +34744 68/push 0/imm32/value:literal +34745 68/push 1/imm32/is-atom?:true +34746 68/push 0x11/imm32/alloc-id:fake:payload +34747 89/<- %edx 4/r32/esp +34748 $test-add-literal-to-mem:initialize-literal: +34749 # var l/edx: (payload var) +34750 68/push 0/imm32/register +34751 68/push 0/imm32/register +34752 68/push 0/imm32/no-stack-offset +34753 68/push 1/imm32/block-depth +34754 52/push-edx +34755 68/push 0x11/imm32/alloc-id:fake +34756 68/push 0/imm32/name +34757 68/push 0/imm32/name +34758 68/push 0x11/imm32/alloc-id:fake:payload +34759 89/<- %edx 4/r32/esp +34760 $test-add-literal-to-mem:initialize-literal-value: +34761 # l->name = "0x34" +34762 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +34763 (copy-array Heap "0x34" %eax) +34764 $test-add-literal-to-mem:initialize-inouts: +34765 # var inouts/esi: (payload stmt-var) = [l] +34766 68/push 0/imm32/is-deref:false +34767 68/push 0/imm32/next +34768 68/push 0/imm32/next +34769 52/push-edx/l +34770 68/push 0x11/imm32/alloc-id:fake +34771 68/push 0x11/imm32/alloc-id:fake:payload +34772 89/<- %esi 4/r32/esp +34773 # var inouts = (handle stmt-var) = [var1, var2] +34774 68/push 0/imm32/is-deref:false +34775 56/push-esi/next +34776 68/push 0x11/imm32/alloc-id:fake +34777 51/push-ecx/var1 +34778 68/push 0x11/imm32/alloc-id:fake +34779 68/push 0x11/imm32/alloc-id:fake:payload +34780 89/<- %esi 4/r32/esp +34781 $test-add-literal-to-mem:initialize-stmt: +34782 # var stmt/esi: (addr statement) +34783 68/push 0/imm32/next +34784 68/push 0/imm32/next +34785 68/push 0/imm32/outputs +34786 68/push 0/imm32/outputs +34787 56/push-esi/inouts +34788 68/push 0x11/imm32/alloc-id:fake +34789 68/push 0/imm32/operation +34790 68/push 0/imm32/operation +34791 68/push 1/imm32/tag:stmt1 +34792 89/<- %esi 4/r32/esp +34793 $test-add-literal-to-mem:initialize-stmt-operation: +34794 # stmt->operation = "add-to" +34795 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +34796 (copy-array Heap "add-to" %eax) +34797 # convert +34798 c7 0/subop/copy *Curr-block-depth 0/imm32 +34799 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +34800 (flush _test-output-buffered-file) +34801 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +34807 # check output +34808 (check-next-stream-line-equal _test-output-stream "81 0/subop/add *(ebp+0x00000008) 0x34/imm32" "F - test-add-literal-to-mem") +34809 # . epilogue +34810 89/<- %esp 5/r32/ebp +34811 5d/pop-to-ebp +34812 c3/return +34813 +34814 test-shift-reg-by-literal: +34815 # var1/ecx <- shift-left 2 +34816 # => +34817 # c1/shift 4/subop/left %ecx 2/imm8 +34818 # +34819 # . prologue +34820 55/push-ebp +34821 89/<- %ebp 4/r32/esp +34822 # setup +34823 (clear-stream _test-output-stream) +34824 (clear-stream $_test-output-buffered-file->buffer) +34825 $test-shift-reg-by-literal:initialize-var-type: +34826 # var type/ecx: (payload type-tree) = int +34827 68/push 0/imm32/right:null +34828 68/push 0/imm32/right:null +34829 68/push 0/imm32/left:unused +34830 68/push 1/imm32/value:int +34831 68/push 1/imm32/is-atom?:true +34832 68/push 0x11/imm32/alloc-id:fake:payload +34833 89/<- %ecx 4/r32/esp +34834 $test-shift-reg-by-literal:initialize-var: +34835 # var v/ecx: (payload var) +34836 68/push 0/imm32/register +34837 68/push 0/imm32/register +34838 68/push 0/imm32/no-stack-offset +34839 68/push 1/imm32/block-depth +34840 51/push-ecx +34841 68/push 0x11/imm32/alloc-id:fake +34842 68/push 0/imm32/name +34843 68/push 0/imm32/name +34844 68/push 0x11/imm32/alloc-id:fake:payload +34845 89/<- %ecx 4/r32/esp +34846 $test-shift-reg-by-literal:initialize-var-name: +34847 # v->name = "v" +34848 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +34849 (copy-array Heap "v" %eax) +34850 $test-shift-reg-by-literal:initialize-var-register: +34851 # v->register = "ecx" +34852 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +34853 (copy-array Heap "ecx" %eax) +34854 $test-shift-reg-by-literal:initialize-literal-type: +34855 # var type/edx: (payload type-tree) = literal +34856 68/push 0/imm32/right:null +34857 68/push 0/imm32/right:null +34858 68/push 0/imm32/left:unused +34859 68/push 0/imm32/value:literal +34860 68/push 1/imm32/is-atom?:true +34861 68/push 0x11/imm32/alloc-id:fake:payload +34862 89/<- %edx 4/r32/esp +34863 $test-shift-reg-by-literal:initialize-literal: +34864 # var l/edx: (payload var) +34865 68/push 0/imm32/register +34866 68/push 0/imm32/register +34867 68/push 0/imm32/no-stack-offset +34868 68/push 1/imm32/block-depth +34869 52/push-edx +34870 68/push 0x11/imm32/alloc-id:fake +34871 68/push 0/imm32/name +34872 68/push 0/imm32/name +34873 68/push 0x11/imm32/alloc-id:fake:payload +34874 89/<- %edx 4/r32/esp +34875 $test-shift-reg-by-literal:initialize-literal-value: +34876 # l->name = "2" +34877 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +34878 (copy-array Heap "2" %eax) +34879 $test-shift-reg-by-literal:initialize-inouts: +34880 # var inouts/esi: (payload stmt-var) = [l] +34881 68/push 0/imm32/is-deref:false +34882 68/push 0/imm32/next +34883 68/push 0/imm32/next +34884 52/push-edx/l +34885 68/push 0x11/imm32/alloc-id:fake +34886 68/push 0x11/imm32/alloc-id:fake:payload +34887 89/<- %esi 4/r32/esp +34888 $test-shift-reg-by-literal:initialize-outputs: +34889 # var outputs/edi: (payload stmt-var) = [v] +34890 68/push 0/imm32/is-deref:false +34891 68/push 0/imm32/next +34892 68/push 0/imm32/next +34893 51/push-ecx/v +34894 68/push 0x11/imm32/alloc-id:fake +34895 68/push 0x11/imm32/alloc-id:fake:payload +34896 89/<- %edi 4/r32/esp +34897 $test-shift-reg-by-literal:initialize-stmt: +34898 # var stmt/esi: (addr statement) +34899 68/push 0/imm32/next +34900 68/push 0/imm32/next +34901 57/push-edi/outputs +34902 68/push 0x11/imm32/alloc-id:fake +34903 56/push-esi/inouts +34904 68/push 0x11/imm32/alloc-id:fake +34905 68/push 0/imm32/operation +34906 68/push 0/imm32/operation +34907 68/push 1/imm32/tag:stmt1 +34908 89/<- %esi 4/r32/esp +34909 $test-shift-reg-by-literal:initialize-stmt-operation: +34910 # stmt->operation = "shift-left" +34911 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +34912 (copy-array Heap "shift-left" %eax) +34913 # convert +34914 c7 0/subop/copy *Curr-block-depth 0/imm32 +34915 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +34916 (flush _test-output-buffered-file) +34917 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +34923 # check output +34924 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left %ecx 2/imm8" "F - test-shift-reg-by-literal") +34925 # . epilogue +34926 89/<- %esp 5/r32/ebp +34927 5d/pop-to-ebp +34928 c3/return +34929 +34930 test-shift-mem-by-literal: +34931 # shift-left var 3 +34932 # => +34933 # c1/shift 4/subop/left *(ebp+8) 3/imm8 +34934 # +34935 # . prologue +34936 55/push-ebp +34937 89/<- %ebp 4/r32/esp +34938 # setup +34939 (clear-stream _test-output-stream) +34940 (clear-stream $_test-output-buffered-file->buffer) +34941 $test-shift-mem-by-literal:initialize-type: +34942 # var type/ecx: (payload type-tree) = int +34943 68/push 0/imm32/right:null +34944 68/push 0/imm32/right:null +34945 68/push 0/imm32/left:unused +34946 68/push 1/imm32/value:int +34947 68/push 1/imm32/is-atom?:true +34948 68/push 0x11/imm32/alloc-id:fake:payload +34949 89/<- %ecx 4/r32/esp +34950 $test-shift-mem-by-literal:initialize-var1: +34951 # var var1/ecx: (payload var) +34952 68/push 0/imm32/register +34953 68/push 0/imm32/register +34954 68/push 8/imm32/stack-offset +34955 68/push 1/imm32/block-depth +34956 51/push-ecx +34957 68/push 0x11/imm32/alloc-id:fake +34958 68/push 0/imm32/name +34959 68/push 0/imm32/name +34960 68/push 0x11/imm32/alloc-id:fake:payload +34961 89/<- %ecx 4/r32/esp +34962 $test-shift-mem-by-literal:initialize-var1-name: +34963 # var1->name = "var1" +34964 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +34965 (copy-array Heap "var1" %eax) +34966 $test-shift-mem-by-literal:initialize-literal-type: +34967 # var type/edx: (payload type-tree) = literal +34968 68/push 0/imm32/right:null +34969 68/push 0/imm32/right:null +34970 68/push 0/imm32/left:unused +34971 68/push 0/imm32/value:literal +34972 68/push 1/imm32/is-atom?:true +34973 68/push 0x11/imm32/alloc-id:fake:payload +34974 89/<- %edx 4/r32/esp +34975 $test-shift-mem-by-literal:initialize-literal: +34976 # var l/edx: (payload var) +34977 68/push 0/imm32/register +34978 68/push 0/imm32/register +34979 68/push 0/imm32/no-stack-offset +34980 68/push 1/imm32/block-depth +34981 52/push-edx +34982 68/push 0x11/imm32/alloc-id:fake +34983 68/push 0/imm32/name +34984 68/push 0/imm32/name +34985 68/push 0x11/imm32/alloc-id:fake:payload +34986 89/<- %edx 4/r32/esp +34987 $test-shift-mem-by-literal:initialize-literal-value: +34988 # l->name = "3" +34989 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +34990 (copy-array Heap "3" %eax) +34991 $test-shift-mem-by-literal:initialize-inouts: +34992 # var inouts/esi: (payload stmt-var) = [l] +34993 68/push 0/imm32/is-deref:false +34994 68/push 0/imm32/next +34995 68/push 0/imm32/next +34996 52/push-edx/l +34997 68/push 0x11/imm32/alloc-id:fake +34998 68/push 0x11/imm32/alloc-id:fake:payload +34999 89/<- %esi 4/r32/esp +35000 # var inouts = (handle stmt-var) = [var1, var2] +35001 68/push 0/imm32/is-deref:false +35002 56/push-esi/next +35003 68/push 0x11/imm32/alloc-id:fake +35004 51/push-ecx/var1 +35005 68/push 0x11/imm32/alloc-id:fake +35006 68/push 0x11/imm32/alloc-id:fake:payload +35007 89/<- %esi 4/r32/esp +35008 $test-shift-mem-by-literal:initialize-stmt: +35009 # var stmt/esi: (addr statement) +35010 68/push 0/imm32/next +35011 68/push 0/imm32/next +35012 68/push 0/imm32/outputs +35013 68/push 0/imm32/outputs +35014 56/push-esi/inouts +35015 68/push 0x11/imm32/alloc-id:fake +35016 68/push 0/imm32/operation +35017 68/push 0/imm32/operation +35018 68/push 1/imm32/tag:stmt1 +35019 89/<- %esi 4/r32/esp +35020 $test-shift-mem-by-literal:initialize-stmt-operation: +35021 # stmt->operation = "shift-left" +35022 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +35023 (copy-array Heap "shift-left" %eax) +35024 # convert +35025 c7 0/subop/copy *Curr-block-depth 0/imm32 +35026 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +35027 (flush _test-output-buffered-file) +35028 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +35034 # check output +35035 (check-next-stream-line-equal _test-output-stream "c1/shift 4/subop/left *(ebp+0x00000008) 3/imm8" "F - test-shift-mem-by-literal") +35036 # . epilogue +35037 89/<- %esp 5/r32/ebp +35038 5d/pop-to-ebp +35039 c3/return +35040 +35041 test-compare-reg-with-reg: +35042 # compare var1/ecx, var2/eax +35043 # => +35044 # 39/compare %ecx 0/r32/eax +35045 # +35046 # . prologue +35047 55/push-ebp +35048 89/<- %ebp 4/r32/esp +35049 # setup +35050 (clear-stream _test-output-stream) +35051 (clear-stream $_test-output-buffered-file->buffer) +35052 $test-compare-reg-with-reg:initialize-type: +35053 # var type/ecx: (payload type-tree) = int +35054 68/push 0/imm32/right:null +35055 68/push 0/imm32/right:null +35056 68/push 0/imm32/left:unused +35057 68/push 1/imm32/value:int +35058 68/push 1/imm32/is-atom?:true +35059 68/push 0x11/imm32/alloc-id:fake:payload +35060 89/<- %ecx 4/r32/esp +35061 $test-compare-reg-with-reg:initialize-var1: +35062 # var var1/ecx: (payload var) +35063 68/push 0/imm32/register +35064 68/push 0/imm32/register +35065 68/push 0/imm32/no-stack-offset +35066 68/push 1/imm32/block-depth +35067 51/push-ecx +35068 68/push 0x11/imm32/alloc-id:fake +35069 68/push 0/imm32/name +35070 68/push 0/imm32/name +35071 68/push 0x11/imm32/alloc-id:fake:payload +35072 89/<- %ecx 4/r32/esp +35073 $test-compare-reg-with-reg:initialize-var1-name: +35074 # var1->name = "var1" +35075 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +35076 (copy-array Heap "var1" %eax) +35077 $test-compare-reg-with-reg:initialize-var1-register: +35078 # var1->register = "ecx" +35079 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +35080 (copy-array Heap "ecx" %eax) +35081 $test-compare-reg-with-reg:initialize-var2: +35082 # var var2/edx: (payload var) +35083 68/push 0/imm32/register +35084 68/push 0/imm32/register +35085 68/push 0/imm32/no-stack-offset +35086 68/push 1/imm32/block-depth +35087 ff 6/subop/push *(ecx+0x10) +35088 68/push 0x11/imm32/alloc-id:fake +35089 68/push 0/imm32/name +35090 68/push 0/imm32/name +35091 68/push 0x11/imm32/alloc-id:fake:payload +35092 89/<- %edx 4/r32/esp +35093 $test-compare-reg-with-reg:initialize-var2-name: +35094 # var2->name = "var2" +35095 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +35096 (copy-array Heap "var2" %eax) +35097 $test-compare-reg-with-reg:initialize-var2-register: +35098 # var2->register = "eax" +35099 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +35100 (copy-array Heap "eax" %eax) +35101 $test-compare-reg-with-reg:initialize-inouts: +35102 # var inouts/esi: (payload stmt-var) = [var2] +35103 68/push 0/imm32/is-deref:false +35104 68/push 0/imm32/next +35105 68/push 0/imm32/next +35106 52/push-edx/var2 +35107 68/push 0x11/imm32/alloc-id:fake +35108 68/push 0x11/imm32/alloc-id:fake:payload +35109 89/<- %esi 4/r32/esp +35110 # inouts = [var1, var2] +35111 68/push 0/imm32/is-deref:false +35112 56/push-esi/next +35113 68/push 0x11/imm32/alloc-id:fake +35114 51/push-ecx/var1 +35115 68/push 0x11/imm32/alloc-id:fake +35116 68/push 0x11/imm32/alloc-id:fake:payload +35117 89/<- %esi 4/r32/esp +35118 $test-compare-reg-with-reg:initialize-stmt: +35119 # var stmt/esi: (addr statement) +35120 68/push 0/imm32/next +35121 68/push 0/imm32/next +35122 68/push 0/imm32/outputs +35123 68/push 0/imm32/outputs +35124 56/push-esi/inouts +35125 68/push 0x11/imm32/alloc-id:fake +35126 68/push 0/imm32/operation +35127 68/push 0/imm32/operation +35128 68/push 1/imm32/tag:stmt1 +35129 89/<- %esi 4/r32/esp +35130 $test-compare-reg-with-reg:initialize-stmt-operation: +35131 # stmt->operation = "compare" +35132 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +35133 (copy-array Heap "compare" %eax) +35134 # convert +35135 c7 0/subop/copy *Curr-block-depth 0/imm32 +35136 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +35137 (flush _test-output-buffered-file) +35138 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +35144 # check output +35145 (check-next-stream-line-equal _test-output-stream "39/compare-> %ecx 0x00000000/r32" "F - test-compare-reg-with-reg") +35146 # . epilogue +35147 89/<- %esp 5/r32/ebp +35148 5d/pop-to-ebp +35149 c3/return +35150 +35151 test-compare-mem-with-reg: +35152 # compare var1, var2/eax +35153 # => +35154 # 39/compare *(ebp+___) 0/r32/eax +35155 # +35156 # . prologue +35157 55/push-ebp +35158 89/<- %ebp 4/r32/esp +35159 # setup +35160 (clear-stream _test-output-stream) +35161 (clear-stream $_test-output-buffered-file->buffer) +35162 $test-compare-mem-with-reg:initialize-type: +35163 # var type/ecx: (payload type-tree) = int +35164 68/push 0/imm32/right:null +35165 68/push 0/imm32/right:null +35166 68/push 0/imm32/left:unused +35167 68/push 1/imm32/value:int +35168 68/push 1/imm32/is-atom?:true +35169 68/push 0x11/imm32/alloc-id:fake:payload +35170 89/<- %ecx 4/r32/esp +35171 $test-compare-mem-with-reg:initialize-var1: +35172 # var var1/ecx: (payload var) +35173 68/push 0/imm32/register +35174 68/push 0/imm32/register +35175 68/push 8/imm32/stack-offset +35176 68/push 1/imm32/block-depth +35177 51/push-ecx +35178 68/push 0x11/imm32/alloc-id:fake +35179 68/push 0/imm32/name +35180 68/push 0/imm32/name +35181 68/push 0x11/imm32/alloc-id:fake:payload +35182 89/<- %ecx 4/r32/esp +35183 $test-compare-mem-with-reg:initialize-var1-name: +35184 # var1->name = "var1" +35185 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +35186 (copy-array Heap "var1" %eax) +35187 $test-compare-mem-with-reg:initialize-var2: +35188 # var var2/edx: (payload var) +35189 68/push 0/imm32/register +35190 68/push 0/imm32/register +35191 68/push 0/imm32/no-stack-offset +35192 68/push 1/imm32/block-depth +35193 ff 6/subop/push *(ecx+0x10) +35194 68/push 0x11/imm32/alloc-id:fake +35195 68/push 0/imm32/name +35196 68/push 0/imm32/name +35197 68/push 0x11/imm32/alloc-id:fake:payload +35198 89/<- %edx 4/r32/esp +35199 $test-compare-mem-with-reg:initialize-var2-name: +35200 # var2->name = "var2" +35201 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +35202 (copy-array Heap "var2" %eax) +35203 $test-compare-mem-with-reg:initialize-var2-register: +35204 # var2->register = "eax" +35205 8d/copy-address *(edx+0x1c) 0/r32/eax # Var-register + 4 +35206 (copy-array Heap "eax" %eax) +35207 $test-compare-mem-with-reg:initialize-inouts: +35208 # var inouts/esi: (payload stmt-var) = [var2] +35209 68/push 0/imm32/is-deref:false +35210 68/push 0/imm32/next +35211 68/push 0/imm32/next +35212 52/push-edx/var2 +35213 68/push 0x11/imm32/alloc-id:fake +35214 68/push 0x11/imm32/alloc-id:fake:payload +35215 89/<- %esi 4/r32/esp +35216 # inouts = [var1, var2] +35217 68/push 0/imm32/is-deref:false +35218 56/push-esi/next +35219 68/push 0x11/imm32/alloc-id:fake +35220 51/push-ecx/var1 +35221 68/push 0x11/imm32/alloc-id:fake +35222 68/push 0x11/imm32/alloc-id:fake:payload +35223 89/<- %esi 4/r32/esp +35224 $test-compare-mem-with-reg:initialize-stmt: +35225 # var stmt/esi: (addr statement) +35226 68/push 0/imm32/next +35227 68/push 0/imm32/next +35228 68/push 0/imm32/outputs +35229 68/push 0/imm32/outputs +35230 56/push-esi/inouts +35231 68/push 0x11/imm32/alloc-id:fake +35232 68/push 0/imm32/operation +35233 68/push 0/imm32/operation +35234 68/push 1/imm32/tag:stmt1 +35235 89/<- %esi 4/r32/esp +35236 $test-compare-mem-with-reg:initialize-stmt-operation: +35237 # stmt->operation = "compare" +35238 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +35239 (copy-array Heap "compare" %eax) +35240 # convert +35241 c7 0/subop/copy *Curr-block-depth 0/imm32 +35242 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +35243 (flush _test-output-buffered-file) +35244 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +35250 # check output +35251 (check-next-stream-line-equal _test-output-stream "39/compare-> *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-mem-with-reg") +35252 # . epilogue +35253 89/<- %esp 5/r32/ebp +35254 5d/pop-to-ebp +35255 c3/return +35256 +35257 test-compare-reg-with-mem: +35258 # compare var1/eax, var2 +35259 # => +35260 # 3b/compare<- *(ebp+___) 0/r32/eax +35261 # +35262 # . prologue +35263 55/push-ebp +35264 89/<- %ebp 4/r32/esp +35265 # setup +35266 (clear-stream _test-output-stream) +35267 (clear-stream $_test-output-buffered-file->buffer) +35268 $test-compare-reg-with-mem:initialize-type: +35269 # var type/ecx: (payload type-tree) = int +35270 68/push 0/imm32/right:null +35271 68/push 0/imm32/right:null +35272 68/push 0/imm32/left:unused +35273 68/push 1/imm32/value:int +35274 68/push 1/imm32/is-atom?:true +35275 68/push 0x11/imm32/alloc-id:fake:payload +35276 89/<- %ecx 4/r32/esp +35277 $test-compare-reg-with-mem:initialize-var1: +35278 # var var1/ecx: (payload var) +35279 68/push 0/imm32/register +35280 68/push 0/imm32/register +35281 68/push 0/imm32/no-stack-offset +35282 68/push 1/imm32/block-depth +35283 51/push-ecx +35284 68/push 0x11/imm32/alloc-id:fake +35285 68/push 0/imm32/name +35286 68/push 0/imm32/name +35287 68/push 0x11/imm32/alloc-id:fake:payload +35288 89/<- %ecx 4/r32/esp +35289 $test-compare-reg-with-mem:initialize-var1-name: +35290 # var1->name = "var1" +35291 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +35292 (copy-array Heap "var1" %eax) +35293 $test-compare-reg-with-mem:initialize-var1-register: +35294 # var1->register = "eax" +35295 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +35296 (copy-array Heap "eax" %eax) +35297 $test-compare-reg-with-mem:initialize-var2: +35298 # var var2/edx: (payload var) +35299 68/push 0/imm32/register +35300 68/push 0/imm32/register +35301 68/push 8/imm32/stack-offset +35302 68/push 1/imm32/block-depth +35303 ff 6/subop/push *(ecx+0x10) +35304 68/push 0x11/imm32/alloc-id:fake +35305 68/push 0/imm32/name +35306 68/push 0/imm32/name +35307 68/push 0x11/imm32/alloc-id:fake:payload +35308 89/<- %edx 4/r32/esp +35309 $test-compare-reg-with-mem:initialize-var2-name: +35310 # var2->name = "var2" +35311 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +35312 (copy-array Heap "var2" %eax) +35313 $test-compare-reg-with-mem:initialize-inouts: +35314 # var inouts/esi: (payload stmt-var) = [var2] +35315 68/push 0/imm32/is-deref:false +35316 68/push 0/imm32/next +35317 68/push 0/imm32/next +35318 52/push-edx/var2 +35319 68/push 0x11/imm32/alloc-id:fake +35320 68/push 0x11/imm32/alloc-id:fake:payload +35321 89/<- %esi 4/r32/esp +35322 # inouts = [var1, var2] +35323 68/push 0/imm32/is-deref:false +35324 56/push-esi/next +35325 68/push 0x11/imm32/alloc-id:fake +35326 51/push-ecx/var1 +35327 68/push 0x11/imm32/alloc-id:fake +35328 68/push 0x11/imm32/alloc-id:fake:payload +35329 89/<- %esi 4/r32/esp +35330 $test-compare-reg-with-mem:initialize-stmt: +35331 # var stmt/esi: (addr statement) +35332 68/push 0/imm32/next +35333 68/push 0/imm32/next +35334 68/push 0/imm32/outputs +35335 68/push 0/imm32/outputs +35336 56/push-esi/inouts +35337 68/push 0x11/imm32/alloc-id:fake +35338 68/push 0/imm32/operation +35339 68/push 0/imm32/operation +35340 68/push 1/imm32/tag:stmt1 +35341 89/<- %esi 4/r32/esp +35342 $test-compare-reg-with-mem:initialize-stmt-operation: +35343 # stmt->operation = "compare" +35344 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +35345 (copy-array Heap "compare" %eax) +35346 # convert +35347 c7 0/subop/copy *Curr-block-depth 0/imm32 +35348 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +35349 (flush _test-output-buffered-file) +35350 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +35356 # check output +35357 (check-next-stream-line-equal _test-output-stream "3b/compare<- *(ebp+0x00000008) 0x00000000/r32" "F - test-compare-reg-with-mem") +35358 # . epilogue +35359 89/<- %esp 5/r32/ebp +35360 5d/pop-to-ebp +35361 c3/return +35362 +35363 test-compare-mem-with-literal: +35364 # compare var1, 0x34 +35365 # => +35366 # 81 7/subop/compare *(ebp+___) 0x34/imm32 +35367 # +35368 # . prologue +35369 55/push-ebp +35370 89/<- %ebp 4/r32/esp +35371 # setup +35372 (clear-stream _test-output-stream) +35373 (clear-stream $_test-output-buffered-file->buffer) +35374 $test-compare-mem-with-literal:initialize-type: +35375 # var type/ecx: (payload type-tree) = int +35376 68/push 0/imm32/right:null +35377 68/push 0/imm32/right:null +35378 68/push 0/imm32/left:unused +35379 68/push 1/imm32/value:int +35380 68/push 1/imm32/is-atom?:true +35381 68/push 0x11/imm32/alloc-id:fake:payload +35382 89/<- %ecx 4/r32/esp +35383 $test-compare-mem-with-literal:initialize-var1: +35384 # var var1/ecx: (payload var) +35385 68/push 0/imm32/register +35386 68/push 0/imm32/register +35387 68/push 8/imm32/stack-offset +35388 68/push 1/imm32/block-depth +35389 51/push-ecx +35390 68/push 0x11/imm32/alloc-id:fake +35391 68/push 0/imm32/name +35392 68/push 0/imm32/name +35393 68/push 0x11/imm32/alloc-id:fake:payload +35394 89/<- %ecx 4/r32/esp +35395 $test-compare-mem-with-literal:initialize-var1-name: +35396 # var1->name = "var1" +35397 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +35398 (copy-array Heap "var1" %eax) +35399 $test-compare-mem-with-literal:initialize-literal-type: +35400 # var type/edx: (payload type-tree) = literal +35401 68/push 0/imm32/right:null +35402 68/push 0/imm32/right:null +35403 68/push 0/imm32/left:unused +35404 68/push 0/imm32/value:literal +35405 68/push 1/imm32/is-atom?:true +35406 68/push 0x11/imm32/alloc-id:fake:payload +35407 89/<- %edx 4/r32/esp +35408 $test-compare-mem-with-literal:initialize-literal: +35409 # var l/edx: (payload var) +35410 68/push 0/imm32/register +35411 68/push 0/imm32/register +35412 68/push 0/imm32/no-stack-offset +35413 68/push 1/imm32/block-depth +35414 52/push-edx +35415 68/push 0x11/imm32/alloc-id:fake +35416 68/push 0/imm32/name +35417 68/push 0/imm32/name +35418 68/push 0x11/imm32/alloc-id:fake:payload +35419 89/<- %edx 4/r32/esp +35420 $test-compare-mem-with-literal:initialize-literal-value: +35421 # l->name = "0x34" +35422 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +35423 (copy-array Heap "0x34" %eax) +35424 $test-compare-mem-with-literal:initialize-inouts: +35425 # var inouts/esi: (payload stmt-var) = [l] +35426 68/push 0/imm32/is-deref:false +35427 68/push 0/imm32/next +35428 68/push 0/imm32/next +35429 52/push-edx/l +35430 68/push 0x11/imm32/alloc-id:fake +35431 68/push 0x11/imm32/alloc-id:fake:payload +35432 89/<- %esi 4/r32/esp +35433 # var inouts = (handle stmt-var) = [var1, var2] +35434 68/push 0/imm32/is-deref:false +35435 56/push-esi/next +35436 68/push 0x11/imm32/alloc-id:fake +35437 51/push-ecx/var1 +35438 68/push 0x11/imm32/alloc-id:fake +35439 68/push 0x11/imm32/alloc-id:fake:payload +35440 89/<- %esi 4/r32/esp +35441 $test-compare-mem-with-literal:initialize-stmt: +35442 # var stmt/esi: (addr statement) +35443 68/push 0/imm32/next +35444 68/push 0/imm32/next +35445 68/push 0/imm32/outputs +35446 68/push 0/imm32/outputs +35447 56/push-esi/inouts +35448 68/push 0x11/imm32/alloc-id:fake +35449 68/push 0/imm32/operation +35450 68/push 0/imm32/operation +35451 68/push 1/imm32/tag:stmt1 +35452 89/<- %esi 4/r32/esp +35453 $test-compare-mem-with-literal:initialize-stmt-operation: +35454 # stmt->operation = "compare" +35455 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +35456 (copy-array Heap "compare" %eax) +35457 # convert +35458 c7 0/subop/copy *Curr-block-depth 0/imm32 +35459 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +35460 (flush _test-output-buffered-file) +35461 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +35467 # check output +35468 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare *(ebp+0x00000008) 0x34/imm32" "F - test-compare-mem-with-literal") +35469 # . epilogue +35470 89/<- %esp 5/r32/ebp +35471 5d/pop-to-ebp +35472 c3/return +35473 +35474 test-compare-eax-with-literal: +35475 # compare var1/eax 0x34 +35476 # => +35477 # 3d/compare-eax-with 0x34/imm32 +35478 # +35479 # . prologue +35480 55/push-ebp +35481 89/<- %ebp 4/r32/esp +35482 # setup +35483 (clear-stream _test-output-stream) +35484 (clear-stream $_test-output-buffered-file->buffer) +35485 $test-compare-eax-with-literal:initialize-type: +35486 # var type/ecx: (payload type-tree) = int +35487 68/push 0/imm32/right:null +35488 68/push 0/imm32/right:null +35489 68/push 0/imm32/left:unused +35490 68/push 1/imm32/value:int +35491 68/push 1/imm32/is-atom?:true +35492 68/push 0x11/imm32/alloc-id:fake:payload +35493 89/<- %ecx 4/r32/esp +35494 $test-compare-eax-with-literal:initialize-var1: +35495 # var var1/ecx: (payload var) +35496 68/push 0/imm32/register +35497 68/push 0/imm32/register +35498 68/push 0/imm32/no-stack-offset +35499 68/push 1/imm32/block-depth +35500 51/push-ecx +35501 68/push 0x11/imm32/alloc-id:fake +35502 68/push 0/imm32/name +35503 68/push 0/imm32/name +35504 68/push 0x11/imm32/alloc-id:fake:payload +35505 89/<- %ecx 4/r32/esp +35506 $test-compare-eax-with-literal:initialize-var1-name: +35507 # var1->name = "var1" +35508 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +35509 (copy-array Heap "var1" %eax) +35510 $test-compare-eax-with-literal:initialize-var1-register: +35511 # v->register = "eax" +35512 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +35513 (copy-array Heap "eax" %eax) +35514 $test-compare-eax-with-literal:initialize-literal-type: +35515 # var type/edx: (payload type-tree) = literal +35516 68/push 0/imm32/right:null +35517 68/push 0/imm32/right:null +35518 68/push 0/imm32/left:unused +35519 68/push 0/imm32/value:literal +35520 68/push 1/imm32/is-atom?:true +35521 68/push 0x11/imm32/alloc-id:fake:payload +35522 89/<- %edx 4/r32/esp +35523 $test-compare-eax-with-literal:initialize-literal: +35524 # var l/edx: (payload var) +35525 68/push 0/imm32/register +35526 68/push 0/imm32/register +35527 68/push 0/imm32/no-stack-offset +35528 68/push 1/imm32/block-depth +35529 52/push-edx +35530 68/push 0x11/imm32/alloc-id:fake +35531 68/push 0/imm32/name +35532 68/push 0/imm32/name +35533 68/push 0x11/imm32/alloc-id:fake:payload +35534 89/<- %edx 4/r32/esp +35535 $test-compare-eax-with-literal:initialize-literal-value: +35536 # l->name = "0x34" +35537 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +35538 (copy-array Heap "0x34" %eax) +35539 $test-compare-eax-with-literal:initialize-inouts: +35540 # var inouts/esi: (payload stmt-var) = [l] +35541 68/push 0/imm32/is-deref:false +35542 68/push 0/imm32/next +35543 68/push 0/imm32/next +35544 52/push-edx/l +35545 68/push 0x11/imm32/alloc-id:fake +35546 68/push 0x11/imm32/alloc-id:fake:payload +35547 89/<- %esi 4/r32/esp +35548 # var inouts = (handle stmt-var) = [var1, var2] +35549 68/push 0/imm32/is-deref:false +35550 56/push-esi/next +35551 68/push 0x11/imm32/alloc-id:fake +35552 51/push-ecx/var1 +35553 68/push 0x11/imm32/alloc-id:fake +35554 68/push 0x11/imm32/alloc-id:fake:payload +35555 89/<- %esi 4/r32/esp +35556 $test-compare-eax-with-literal:initialize-stmt: +35557 # var stmt/esi: (addr statement) +35558 68/push 0/imm32/next +35559 68/push 0/imm32/next +35560 68/push 0/imm32/outputs +35561 68/push 0/imm32/outputs +35562 56/push-esi/inouts +35563 68/push 0x11/imm32/alloc-id:fake +35564 68/push 0/imm32/operation +35565 68/push 0/imm32/operation +35566 68/push 1/imm32/tag:stmt1 +35567 89/<- %esi 4/r32/esp +35568 $test-compare-eax-with-literal:initialize-stmt-operation: +35569 # stmt->operation = "compare" +35570 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +35571 (copy-array Heap "compare" %eax) +35572 # convert +35573 c7 0/subop/copy *Curr-block-depth 0/imm32 +35574 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +35575 (flush _test-output-buffered-file) +35576 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +35582 # check output +35583 (check-next-stream-line-equal _test-output-stream "3d/compare-eax-with 0x34/imm32" "F - test-compare-eax-with-literal") +35584 # . epilogue +35585 89/<- %esp 5/r32/ebp +35586 5d/pop-to-ebp +35587 c3/return +35588 +35589 test-compare-reg-with-literal: +35590 # compare var1/ecx 0x34 +35591 # => +35592 # 81 7/subop/compare %ecx 0x34/imm32 +35593 # +35594 # . prologue +35595 55/push-ebp +35596 89/<- %ebp 4/r32/esp +35597 # setup +35598 (clear-stream _test-output-stream) +35599 (clear-stream $_test-output-buffered-file->buffer) +35600 $test-compare-reg-with-literal:initialize-type: +35601 # var type/ecx: (payload type-tree) = int +35602 68/push 0/imm32/right:null +35603 68/push 0/imm32/right:null +35604 68/push 0/imm32/left:unused +35605 68/push 1/imm32/value:int +35606 68/push 1/imm32/is-atom?:true +35607 68/push 0x11/imm32/alloc-id:fake:payload +35608 89/<- %ecx 4/r32/esp +35609 $test-compare-reg-with-literal:initialize-var1: +35610 # var var1/ecx: (payload var) +35611 68/push 0/imm32/register +35612 68/push 0/imm32/register +35613 68/push 0/imm32/no-stack-offset +35614 68/push 1/imm32/block-depth +35615 51/push-ecx +35616 68/push 0x11/imm32/alloc-id:fake +35617 68/push 0/imm32/name +35618 68/push 0/imm32/name +35619 68/push 0x11/imm32/alloc-id:fake:payload +35620 89/<- %ecx 4/r32/esp +35621 $test-compare-reg-with-literal:initialize-var1-name: +35622 # var1->name = "var1" +35623 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +35624 (copy-array Heap "var1" %eax) +35625 $test-compare-reg-with-literal:initialize-var1-register: +35626 # v->register = "ecx" +35627 8d/copy-address *(ecx+0x1c) 0/r32/eax # Var-register + 4 +35628 (copy-array Heap "ecx" %eax) +35629 $test-compare-reg-with-literal:initialize-literal-type: +35630 # var type/edx: (payload type-tree) = literal +35631 68/push 0/imm32/right:null +35632 68/push 0/imm32/right:null +35633 68/push 0/imm32/left:unused +35634 68/push 0/imm32/value:literal +35635 68/push 1/imm32/is-atom?:true +35636 68/push 0x11/imm32/alloc-id:fake:payload +35637 89/<- %edx 4/r32/esp +35638 $test-compare-reg-with-literal:initialize-literal: +35639 # var l/edx: (payload var) +35640 68/push 0/imm32/register +35641 68/push 0/imm32/register +35642 68/push 0/imm32/no-stack-offset +35643 68/push 1/imm32/block-depth +35644 52/push-edx +35645 68/push 0x11/imm32/alloc-id:fake +35646 68/push 0/imm32/name +35647 68/push 0/imm32/name +35648 68/push 0x11/imm32/alloc-id:fake:payload +35649 89/<- %edx 4/r32/esp +35650 $test-compare-reg-with-literal:initialize-literal-value: +35651 # l->name = "0x34" +35652 8d/copy-address *(edx+4) 0/r32/eax # Var-name + 4 +35653 (copy-array Heap "0x34" %eax) +35654 $test-compare-reg-with-literal:initialize-inouts: +35655 # var inouts/esi: (payload stmt-var) = [l] +35656 68/push 0/imm32/is-deref:false +35657 68/push 0/imm32/next +35658 68/push 0/imm32/next +35659 52/push-edx/l +35660 68/push 0x11/imm32/alloc-id:fake +35661 68/push 0x11/imm32/alloc-id:fake:payload +35662 89/<- %esi 4/r32/esp +35663 # var inouts = (handle stmt-var) = [var1, var2] +35664 68/push 0/imm32/is-deref:false +35665 56/push-esi/next +35666 68/push 0x11/imm32/alloc-id:fake +35667 51/push-ecx/var1 +35668 68/push 0x11/imm32/alloc-id:fake +35669 68/push 0x11/imm32/alloc-id:fake:payload +35670 89/<- %esi 4/r32/esp +35671 $test-compare-reg-with-literal:initialize-stmt: +35672 # var stmt/esi: (addr statement) +35673 68/push 0/imm32/next +35674 68/push 0/imm32/next +35675 68/push 0/imm32/outputs +35676 68/push 0/imm32/outputs +35677 56/push-esi/inouts +35678 68/push 0x11/imm32/alloc-id:fake +35679 68/push 0/imm32/operation +35680 68/push 0/imm32/operation +35681 68/push 1/imm32/tag:stmt1 +35682 89/<- %esi 4/r32/esp +35683 $test-compare-reg-with-literal:initialize-stmt-operation: +35684 # stmt->operation = "compare" +35685 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +35686 (copy-array Heap "compare" %eax) +35687 # convert +35688 c7 0/subop/copy *Curr-block-depth 0/imm32 +35689 (emit-subx-stmt _test-output-buffered-file %esi Primitives Stderr 0) +35690 (flush _test-output-buffered-file) +35691 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +35697 # check output +35698 (check-next-stream-line-equal _test-output-stream "81 7/subop/compare %ecx 0x34/imm32" "F - test-compare-reg-with-literal") +35699 # . epilogue +35700 89/<- %esp 5/r32/ebp +35701 5d/pop-to-ebp +35702 c3/return +35703 +35704 test-emit-subx-stmt-function-call: +35705 # Call a function on a variable on the stack. +35706 # f foo +35707 # => +35708 # (f *(ebp-8)) +35709 # (Changing the function name supports overloading in general, but here it +35710 # just serves to help disambiguate things.) +35711 # +35712 # There's a variable on the var stack as follows: +35713 # name: 'foo' +35714 # type: int +35715 # stack-offset: -8 +35716 # +35717 # There's nothing in primitives. +35718 # +35719 # We don't perform any checking here on the type of 'f'. +35720 # +35721 # . prologue +35722 55/push-ebp +35723 89/<- %ebp 4/r32/esp +35724 # setup +35725 (clear-stream _test-output-stream) +35726 (clear-stream $_test-output-buffered-file->buffer) +35727 $test-emit-subx-function-call:initialize-type: +35728 # var type/ecx: (payload type-tree) = int +35729 68/push 0/imm32/right:null +35730 68/push 0/imm32/right:null +35731 68/push 0/imm32/left:unused +35732 68/push 1/imm32/value:int +35733 68/push 1/imm32/is-atom?:true +35734 68/push 0x11/imm32/alloc-id:fake:payload +35735 89/<- %ecx 4/r32/esp +35736 $test-emit-subx-function-call:initialize-var: +35737 # var var-foo/ecx: (payload var) = var(type) +35738 68/push 0/imm32/no-register +35739 68/push 0/imm32/no-register +35740 68/push -8/imm32/stack-offset +35741 68/push 1/imm32/block-depth +35742 51/push-ecx/type +35743 68/push 0x11/imm32/alloc-id:fake +35744 68/push 0/imm32/name +35745 68/push 0/imm32/name +35746 68/push 0x11/imm32/alloc-id:fake:payload +35747 89/<- %ecx 4/r32/esp +35748 $test-emit-subx-function-call:initialize-var-name: +35749 # var-foo->name = "foo" +35750 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +35751 (copy-array Heap "foo" %eax) +35752 $test-emit-subx-function-call:initialize-stmt-var: +35753 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) +35754 68/push 0/imm32/is-deref:false +35755 68/push 0/imm32/next +35756 68/push 0/imm32/next +35757 51/push-ecx/var-foo +35758 68/push 0x11/imm32/alloc-id:fake +35759 68/push 0x11/imm32/alloc-id:fake:payload +35760 89/<- %ebx 4/r32/esp +35761 $test-emit-subx-function-call:initialize-stmt: +35762 # var stmt/esi: (addr statement) +35763 68/push 0/imm32/no-outputs +35764 68/push 0/imm32/no-outputs +35765 53/push-ebx/inouts +35766 68/push 0x11/imm32/alloc-id:fake +35767 68/push 0/imm32/operation +35768 68/push 0/imm32/operation +35769 68/push 1/imm32/tag +35770 89/<- %esi 4/r32/esp +35771 $test-emit-subx-function-call:initialize-stmt-operation: +35772 # stmt->operation = "f" +35773 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +35774 (copy-array Heap "f" %eax) +35775 # convert +35776 c7 0/subop/copy *Curr-block-depth 0/imm32 +35777 (emit-subx-stmt _test-output-buffered-file %esi 0 Stderr 0) +35778 (flush _test-output-buffered-file) +35779 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +35785 # check output +35786 (check-next-stream-line-equal _test-output-stream "(f *(ebp+0xfffffff8))" "F - test-emit-subx-stmt-function-call") +35787 # . epilogue +35788 89/<- %esp 5/r32/ebp +35789 5d/pop-to-ebp +35790 c3/return +35791 +35792 test-emit-subx-stmt-function-call-with-literal-arg: +35793 # Call a function on a literal. +35794 # f 0x34 +35795 # => +35796 # (f2 0x34) +35797 # +35798 # . prologue +35799 55/push-ebp +35800 89/<- %ebp 4/r32/esp +35801 # setup +35802 (clear-stream _test-output-stream) +35803 (clear-stream $_test-output-buffered-file->buffer) +35804 $test-emit-subx-function-call-with-literal-arg:initialize-type: +35805 # var type/ecx: (payload type-tree) = int +35806 68/push 0/imm32/right:null +35807 68/push 0/imm32/right:null +35808 68/push 0/imm32/left:unused +35809 68/push 0/imm32/value:literal +35810 68/push 1/imm32/is-atom?:true +35811 68/push 0x11/imm32/alloc-id:fake:payload +35812 89/<- %ecx 4/r32/esp +35813 $test-emit-subx-function-call-with-literal-arg:initialize-var: +35814 # var var-foo/ecx: (payload var) = var(lit) +35815 68/push 0/imm32/no-register +35816 68/push 0/imm32/no-register +35817 68/push 0/imm32/no-stack-offset +35818 68/push 1/imm32/block-depth +35819 51/push-ecx/type +35820 68/push 0x11/imm32/alloc-id:fake +35821 68/push 0/imm32/name +35822 68/push 0/imm32/name +35823 68/push 0x11/imm32/alloc-id:fake:payload +35824 89/<- %ecx 4/r32/esp +35825 $test-emit-subx-function-call-with-literal-arg:initialize-var-name: +35826 # var-foo->name = "0x34" +35827 8d/copy-address *(ecx+4) 0/r32/eax # Var-name + 4 +35828 (copy-array Heap "0x34" %eax) +35829 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-var: +35830 # var operand/ebx: (payload stmt-var) = stmt-var(var-foo) +35831 68/push 0/imm32/is-deref:false +35832 68/push 0/imm32/next +35833 68/push 0/imm32/next +35834 51/push-ecx/var-foo +35835 68/push 0x11/imm32/alloc-id:fake +35836 68/push 0x11/imm32/alloc-id:fake:payload +35837 89/<- %ebx 4/r32/esp +35838 $test-emit-subx-function-call-with-literal-arg:initialize-stmt: +35839 # var stmt/esi: (addr statement) +35840 68/push 0/imm32/no-outputs +35841 68/push 0/imm32/no-outputs +35842 53/push-ebx/inouts +35843 68/push 0x11/imm32/alloc-id:fake +35844 68/push 0/imm32/operation +35845 68/push 0/imm32/operation +35846 68/push 1/imm32/tag +35847 89/<- %esi 4/r32/esp +35848 $test-emit-subx-function-call-with-literal-arg:initialize-stmt-operation: +35849 # stmt->operation = "f" +35850 8d/copy-address *(esi+4) 0/r32/eax # Stmt1-operation +35851 (copy-array Heap "f" %eax) +35852 # convert +35853 c7 0/subop/copy *Curr-block-depth 0/imm32 +35854 (emit-subx-stmt _test-output-buffered-file %esi 0 %ebx Stderr 0) +35855 (flush _test-output-buffered-file) +35856 +-- 6 lines: #? # dump _test-output-stream -------------------------------------------------------------------------------------------------------------------------------------------------------------------- +35862 # check output +35863 (check-next-stream-line-equal _test-output-stream "(f 0x34)" "F - test-emit-subx-stmt-function-call-with-literal-arg") +35864 # . epilogue +35865 89/<- %esp 5/r32/ebp +35866 5d/pop-to-ebp +35867 c3/return +35868 +35869 emit-indent: # out: (addr buffered-file), n: int +35870 # . prologue +35871 55/push-ebp +35872 89/<- %ebp 4/r32/esp +35873 # . save registers +35874 50/push-eax +35875 # var i/eax: int = n +35876 8b/-> *(ebp+0xc) 0/r32/eax +35877 { +35878 # if (i <= 0) break +35879 3d/compare-eax-with 0/imm32 +35880 7e/jump-if-<= break/disp8 +35881 (write-buffered *(ebp+8) " ") +35882 48/decrement-eax +35883 eb/jump loop/disp8 +35884 } +35885 $emit-indent:end: +35886 # . restore registers +35887 58/pop-to-eax +35888 # . epilogue +35889 89/<- %esp 5/r32/ebp +35890 5d/pop-to-ebp +35891 c3/return +35892 +35893 emit-subx-prologue: # out: (addr buffered-file) +35894 # . prologue +35895 55/push-ebp +35896 89/<- %ebp 4/r32/esp +35897 # +35898 (write-buffered *(ebp+8) " # . prologue\n") +35899 (write-buffered *(ebp+8) " 55/push-ebp\n") +35900 (write-buffered *(ebp+8) " 89/<- %ebp 4/r32/esp\n") +35901 $emit-subx-prologue:end: +35902 # . epilogue +35903 89/<- %esp 5/r32/ebp +35904 5d/pop-to-ebp +35905 c3/return +35906 +35907 emit-subx-epilogue: # out: (addr buffered-file) +35908 # . prologue +35909 55/push-ebp +35910 89/<- %ebp 4/r32/esp +35911 # +35912 (write-buffered *(ebp+8) " # . epilogue\n") +35913 (write-buffered *(ebp+8) " 89/<- %esp 5/r32/ebp\n") +35914 (write-buffered *(ebp+8) " 5d/pop-to-ebp\n") +35915 (write-buffered *(ebp+8) " c3/return\n") +35916 $emit-subx-epilogue:end: +35917 # . epilogue +35918 89/<- %esp 5/r32/ebp +35919 5d/pop-to-ebp +35920 c3/return diff --git a/html/apps/sigils.subx.html b/html/apps/sigils.subx.html index fc4ec0a8..37609093 100644 --- a/html/apps/sigils.subx.html +++ b/html/apps/sigils.subx.html @@ -60,8 +60,8 @@ if ('onhashchange' in window) { https://github.com/akkartik/mu/blob/master/apps/sigils.subx 
-   1 # Experimental syntax sugar for addressing modes that expand into /rm32 and
-   2 # other related arguments.
+   1 # Syntax sugar for addressing modes that expand into /rm32 and other related
+   2 # arguments.
    3 #
    4 # To run:
    5 #   $ ./bootstrap translate init.linux 0*.subx apps/subx-params.subx apps/sigils.subx  -o apps/sigils
diff --git a/html/apps/tile/data.mu.html b/html/apps/tile/data.mu.html
index 3e3eacd4..9cfd5f38 100644
--- a/html/apps/tile/data.mu.html
+++ b/html/apps/tile/data.mu.html
@@ -444,11 +444,11 @@ if ('onhashchange' in window) {
 385   var body-ah/edi: (addr handle line) <- address body-storage
 386   function-body functions, function-name, body-ah
 387   var body/eax: (addr line) <- lookup *body-ah
-388   var result/eax: int <- line-length body
+388   var result/eax: int <- num-words-in-line body
 389   return result
 390 }
 391 
-392 fn line-length _in: (addr line) -> _/eax: int {
+392 fn num-words-in-line _in: (addr line) -> _/eax: int {
 393   var in/esi: (addr line) <- copy _in
 394   var curr-ah/ecx: (addr handle word) <- get in, data
 395   var result/edi: int <- copy 0
@@ -678,73 +678,146 @@ if ('onhashchange' in window) {
 619   move-final-element-to-start-of-line list
 620 }
 621 
-622 fn push-to-call-path-element list: (addr handle call-path-element), new: (addr handle word) {
-623   var new-element-storage: (handle call-path-element)
-624   var new-element-ah/edi: (addr handle call-path-element) <- address new-element-storage
-625   allocate new-element-ah
-626   var new-element/eax: (addr call-path-element) <- lookup *new-element-ah
-627   # save word
-628   var dest/ecx: (addr handle word) <- get new-element, word
-629   copy-object new, dest
-630   # save next
-631   var dest2/ecx: (addr handle call-path-element) <- get new-element, next
-632   copy-object list, dest2
-633   # return
-634   copy-object new-element-ah, list
-635 }
-636 
-637 fn drop-from-call-path-element _list: (addr handle call-path-element) {
-638   var list-ah/esi: (addr handle call-path-element) <- copy _list
-639   var list/eax: (addr call-path-element) <- lookup *list-ah
-640   var next/eax: (addr handle call-path-element) <- get list, next
-641   copy-object next, _list
-642 }
-643 
-644 fn drop-nested-calls _list: (addr handle call-path-element) {
-645   var list-ah/esi: (addr handle call-path-element) <- copy _list
-646   var list/eax: (addr call-path-element) <- lookup *list-ah
-647   var next-ah/edi: (addr handle call-path-element) <- get list, next
-648   var next/eax: (addr call-path-element) <- lookup *next-ah
-649   compare next, 0
-650   break-if-=
-651   copy-object next-ah, _list
-652   drop-nested-calls _list
-653 }
-654 
-655 fn dump-call-path-element screen: (addr screen), _x-ah: (addr handle call-path-element) {
-656   var x-ah/ecx: (addr handle call-path-element) <- copy _x-ah
-657   var _x/eax: (addr call-path-element) <- lookup *x-ah
-658   var x/esi: (addr call-path-element) <- copy _x
-659   var word-ah/eax: (addr handle word) <- get x, word
-660   var word/eax: (addr word) <- lookup *word-ah
-661   print-word screen, word
-662   var next-ah/ecx: (addr handle call-path-element) <- get x, next
-663   var next/eax: (addr call-path-element) <- lookup *next-ah
-664   compare next, 0
-665   {
-666     break-if-=
-667     print-string screen, " "
-668     dump-call-path-element screen, next-ah
-669     return
-670   }
-671   print-string screen, "\n"
-672 }
-673 
-674 fn dump-call-paths screen: (addr screen), _x-ah: (addr handle call-path) {
-675   var x-ah/ecx: (addr handle call-path) <- copy _x-ah
-676   var x/eax: (addr call-path) <- lookup *x-ah
-677   compare x, 0
-678   break-if-=
-679   var src/ecx: (addr handle call-path-element) <- get x, data
-680   dump-call-path-element screen, src
-681   var next-ah/ecx: (addr handle call-path) <- get x, next
-682   var next/eax: (addr call-path) <- lookup *next-ah
-683   compare next, 0
-684   {
-685     break-if-=
-686     dump-call-paths screen, next-ah
-687   }
-688 }
+622 fn move-final-element-to-end-of-line list: (addr handle call-path-element) {
+623   var final-ah/eax: (addr handle call-path-element) <- copy list
+624   var final/eax: (addr call-path-element) <- lookup *final-ah
+625   var val-ah/ecx: (addr handle word) <- get final, word
+626   var val/eax: (addr word) <- lookup *val-ah
+627   var new-ah/edx: (addr handle word) <- get val, next
+628   var target/eax: (addr word) <- lookup *new-ah
+629   compare target, 0
+630   break-if-=
+631   copy-object new-ah, val-ah
+632   move-final-element-to-end-of-line list
+633 }
+634 
+635 fn push-to-call-path-element list: (addr handle call-path-element), new: (addr handle word) {
+636   var new-element-storage: (handle call-path-element)
+637   var new-element-ah/edi: (addr handle call-path-element) <- address new-element-storage
+638   allocate new-element-ah
+639   var new-element/eax: (addr call-path-element) <- lookup *new-element-ah
+640   # save word
+641   var dest/ecx: (addr handle word) <- get new-element, word
+642   copy-object new, dest
+643   # save next
+644   var dest2/ecx: (addr handle call-path-element) <- get new-element, next
+645   copy-object list, dest2
+646   # return
+647   copy-object new-element-ah, list
+648 }
+649 
+650 fn drop-from-call-path-element _list: (addr handle call-path-element) {
+651   var list-ah/esi: (addr handle call-path-element) <- copy _list
+652   var list/eax: (addr call-path-element) <- lookup *list-ah
+653   var next/eax: (addr handle call-path-element) <- get list, next
+654   copy-object next, _list
+655 }
+656 
+657 fn drop-nested-calls _list: (addr handle call-path-element) {
+658   var list-ah/esi: (addr handle call-path-element) <- copy _list
+659   var list/eax: (addr call-path-element) <- lookup *list-ah
+660   var next-ah/edi: (addr handle call-path-element) <- get list, next
+661   var next/eax: (addr call-path-element) <- lookup *next-ah
+662   compare next, 0
+663   break-if-=
+664   copy-object next-ah, _list
+665   drop-nested-calls _list
+666 }
+667 
+668 fn dump-call-path-element screen: (addr screen), _x-ah: (addr handle call-path-element) {
+669   var x-ah/ecx: (addr handle call-path-element) <- copy _x-ah
+670   var _x/eax: (addr call-path-element) <- lookup *x-ah
+671   var x/esi: (addr call-path-element) <- copy _x
+672   var word-ah/eax: (addr handle word) <- get x, word
+673   var word/eax: (addr word) <- lookup *word-ah
+674   print-word screen, word
+675   var next-ah/ecx: (addr handle call-path-element) <- get x, next
+676   var next/eax: (addr call-path-element) <- lookup *next-ah
+677   compare next, 0
+678   {
+679     break-if-=
+680     print-string screen, " "
+681     dump-call-path-element screen, next-ah
+682     return
+683   }
+684   print-string screen, "\n"
+685 }
+686 
+687 fn dump-call-paths screen: (addr screen), _x-ah: (addr handle call-path) {
+688   var x-ah/ecx: (addr handle call-path) <- copy _x-ah
+689   var x/eax: (addr call-path) <- lookup *x-ah
+690   compare x, 0
+691   break-if-=
+692   var src/ecx: (addr handle call-path-element) <- get x, data
+693   dump-call-path-element screen, src
+694   var next-ah/ecx: (addr handle call-path) <- get x, next
+695   var next/eax: (addr call-path) <- lookup *next-ah
+696   compare next, 0
+697   {
+698     break-if-=
+699     dump-call-paths screen, next-ah
+700   }
+701 }
+702 
+703 fn function-width _self: (addr function) -> _/eax: int {
+704   var self/esi: (addr function) <- copy _self
+705   var args/ecx: (addr handle word) <- get self, args
+706   var arg-width/eax: int <- word-list-length args
+707   var result/edi: int <- copy arg-width
+708   result <- add 4  # function-header-indent + body-indent
+709   var body-ah/eax: (addr handle line) <- get self, body
+710   var body-width/eax: int <- body-width body-ah
+711   body-width <- add 1  # right margin
+712   body-width <- add 2  # body-indent for "≡ "
+713   compare result, body-width
+714   {
+715     break-if->=
+716     result <- copy body-width
+717   }
+718   return result
+719 }
+720 
+721 fn body-width lines: (addr handle line) -> _/eax: int {
+722   var curr-ah/esi: (addr handle line) <- copy lines
+723   var result/edi: int <- copy 0
+724   {
+725     var curr/eax: (addr line) <- lookup *curr-ah
+726     compare curr, 0
+727     break-if-=
+728     {
+729       var words/ecx: (addr handle word) <- get curr, data
+730       var curr-len/eax: int <- word-list-length words
+731       compare curr-len, result
+732       break-if-<=
+733       result <- copy curr-len
+734     }
+735     curr-ah <- get curr, next
+736     loop
+737   }
+738   return result
+739 }
+740 
+741 fn function-height _self: (addr function) -> _/eax: int {
+742   var self/esi: (addr function) <- copy _self
+743   var body-ah/eax: (addr handle line) <- get self, body
+744   var result/eax: int <- line-list-length body-ah
+745   result <- increment  # for function header
+746   return result
+747 }
+748 
+749 fn line-list-length lines: (addr handle line) -> _/eax: int {
+750   var curr-ah/esi: (addr handle line) <- copy lines
+751   var result/edi: int <- copy 0
+752   {
+753     var curr/eax: (addr line) <- lookup *curr-ah
+754     compare curr, 0
+755     break-if-=
+756     curr-ah <- get curr, next
+757     result <- increment
+758     loop
+759   }
+760   return result
+761 }
diff --git a/html/apps/tile/environment.mu.html b/html/apps/tile/environment.mu.html index a2080d59..3fedae36 100644 --- a/html/apps/tile/environment.mu.html +++ b/html/apps/tile/environment.mu.html @@ -101,7 +101,7 @@ if ('onhashchange' in window) { 41 var screen/edi: (addr screen) <- copy _screen 42 var dest/edx: (addr int) <- get env, code-separator-col 43 var tmp/eax: int <- copy *dest - 44 clear-canvas env + 44 clear-canvas env 45 tmp <- add 2 # repl-margin-left 46 move-cursor screen, 3, tmp # input-row 47 } @@ -141,7 +141,7 @@ if ('onhashchange' in window) { 81 break-if-= 82 #? print-string 0, "processing function definition\n" 83 var functions/ecx: (addr handle function) <- get self, functions - 84 process-sandbox-define sandbox, functions, key + 84 process-sandbox-define sandbox, functions, key 85 break $process:body 86 } 87 #? print-string 0, "processing sandbox\n" @@ -307,9 +307,9 @@ if ('onhashchange' in window) { 247 var callee-h: (handle function) 248 var callee-ah/edx: (addr handle function) <- address callee-h 249 var functions/ebx: (addr handle function) <- get self, functions - 250 callee functions, next-word, callee-ah - 251 var callee/eax: (addr function) <- lookup *callee-ah - 252 var callee-body-ah/eax: (addr handle line) <- get callee, body + 250 callee functions, next-word, callee-ah + 251 var callee/eax: (addr function) <- lookup *callee-ah + 252 var callee-body-ah/eax: (addr handle line) <- get callee, body 253 var callee-body/eax: (addr line) <- lookup *callee-body-ah 254 var callee-body-first-word/edx: (addr handle word) <- get callee-body, data 255 push-to-call-path-element cursor-call-path, callee-body-first-word @@ -329,14 +329,14 @@ if ('onhashchange' in window) { 269 { 270 break-if-!= 271 # toggle display of subsidiary stack - 272 toggle-cursor-word sandbox + 272 toggle-cursor-word sandbox 273 break $process-sandbox:body 274 } 275 compare key, 0xc # ctrl-l 276 $process-sandbox:new-line: { 277 break-if-!= 278 # new line in sandbox - 279 append-line sandbox + 279 append-line sandbox 280 break $process-sandbox:body 281 } 282 # word-based motions @@ -411,7 +411,7 @@ if ('onhashchange' in window) { 351 var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path 352 drop-nested-calls cursor-call-path-ah 353 move-final-element-to-start-of-line cursor-call-path-ah - 354 # move cursor to start of initial word + 354 # move cursor to start of word 355 var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah 356 var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word 357 var cursor-word/eax: (addr word) <- lookup *cursor-word-ah @@ -423,13 +423,13 @@ if ('onhashchange' in window) { 363 compare key, 5 # ctrl-e 364 $process-sandbox:end-of-line: { 365 break-if-!= - 366 # move cursor to final word of sandbox - 367 var cursor-call-path-ah/ecx: (addr handle call-path-element) <- get sandbox, cursor-call-path - 368 initialize-path-from-sandbox sandbox, cursor-call-path-ah - 369 var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah - 370 var dest/eax: (addr handle word) <- get cursor-call-path, word - 371 final-word dest, dest - 372 # move cursor to end of final word + 366 # move cursor up past all calls and to start of line + 367 var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path + 368 drop-nested-calls cursor-call-path-ah + 369 move-final-element-to-end-of-line cursor-call-path-ah + 370 # move cursor to end of word + 371 var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah + 372 var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word 373 var cursor-word/eax: (addr word) <- lookup *cursor-word-ah 374 cursor-to-end cursor-word 375 # this works because expanded words lie to the right of their bodies @@ -560,7 +560,7 @@ if ('onhashchange' in window) { 500 } 501 # otherwise insert key within current word 502 var g/edx: grapheme <- copy key - 503 var print?/eax: boolean <- real-grapheme? key + 503 var print?/eax: boolean <- real-grapheme? key 504 $process-sandbox:real-grapheme: { 505 compare print?, 0 # false 506 break-if-= @@ -582,986 +582,986 @@ if ('onhashchange' in window) { 522 compare key, 0x1b # esc 523 $process-sandbox-rename:cancel: { 524 break-if-!= - 525 var empty: (handle word) - 526 copy-handle empty, new-name-ah - 527 break $process-sandbox-rename:body - 528 } - 529 # if 'enter' pressed, perform rename - 530 compare key, 0xa # enter - 531 $process-sandbox-rename:commit: { - 532 break-if-!= - 533 #? print-string 0, "rename\n" - 534 # new line - 535 var new-line-h: (handle line) - 536 var new-line-ah/eax: (addr handle line) <- address new-line-h - 537 allocate new-line-ah - 538 var new-line/eax: (addr line) <- lookup *new-line-ah - 539 initialize-line new-line - 540 var new-line-word-ah/ecx: (addr handle word) <- get new-line, data - 541 { - 542 # move word at cursor to new line - 543 var cursor-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path - 544 var cursor/eax: (addr call-path-element) <- lookup *cursor-ah - 545 var word-at-cursor-ah/eax: (addr handle word) <- get cursor, word - 546 #? print-string 0, "cursor before at word " - 547 #? { - 548 #? var cursor-word/eax: (addr word) <- lookup *word-at-cursor-ah - 549 #? print-word 0, cursor-word - 550 #? print-string 0, "\n" - 551 #? } - 552 move-word-contents word-at-cursor-ah, new-line-word-ah - 553 # copy name to word at cursor - 554 copy-word-contents-before-cursor new-name-ah, word-at-cursor-ah - 555 #? print-string 0, "cursor after at word " - 556 #? { - 557 #? var cursor-word/eax: (addr word) <- lookup *word-at-cursor-ah - 558 #? print-word 0, cursor-word - 559 #? print-string 0, "\n" - 560 #? var foo/eax: int <- copy cursor-word - 561 #? print-int32-hex 0, foo - 562 #? print-string 0, "\n" - 563 #? } - 564 #? print-string 0, "new name word " - 565 #? { - 566 #? var new-name/eax: (addr word) <- lookup *new-name-ah - 567 #? print-word 0, new-name - 568 #? print-string 0, "\n" - 569 #? var foo/eax: int <- copy new-name - 570 #? print-int32-hex 0, foo - 571 #? print-string 0, "\n" - 572 #? } - 573 } - 574 # prepend '=' to name - 575 { - 576 var new-name/eax: (addr word) <- lookup *new-name-ah - 577 cursor-to-start new-name - 578 add-grapheme-to-word new-name, 0x3d # '=' - 579 } - 580 # append name to new line - 581 chain-words new-line-word-ah, new-name-ah - 582 # new-line->next = sandbox->data - 583 var new-line-next/ecx: (addr handle line) <- get new-line, next - 584 var sandbox-slot/edx: (addr handle line) <- get sandbox, data - 585 copy-object sandbox-slot, new-line-next - 586 # sandbox->data = new-line - 587 copy-handle new-line-h, sandbox-slot - 588 # clear partial-name-for-cursor-word - 589 var empty: (handle word) - 590 copy-handle empty, new-name-ah - 591 #? # XXX - 592 #? var cursor-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path - 593 #? var cursor/eax: (addr call-path-element) <- lookup *cursor-ah - 594 #? var word-at-cursor-ah/eax: (addr handle word) <- get cursor, word - 595 #? print-string 0, "cursor after rename: " - 596 #? { - 597 #? var cursor-word/eax: (addr word) <- lookup *word-at-cursor-ah - 598 #? print-word 0, cursor-word - 599 #? print-string 0, " -- " - 600 #? var foo/eax: int <- copy cursor-word - 601 #? print-int32-hex 0, foo - 602 #? print-string 0, "\n" - 603 #? } - 604 break $process-sandbox-rename:body - 605 } - 606 # - 607 compare key, 0x7f # del (backspace on Macs) - 608 $process-sandbox-rename:backspace: { - 609 break-if-!= - 610 # if not at start, delete grapheme before cursor - 611 var new-name/eax: (addr word) <- lookup *new-name-ah - 612 var at-start?/eax: boolean <- cursor-at-start? new-name - 613 compare at-start?, 0 # false - 614 { - 615 break-if-!= - 616 var new-name/eax: (addr word) <- lookup *new-name-ah - 617 delete-before-cursor new-name - 618 } - 619 break $process-sandbox-rename:body - 620 } - 621 # otherwise insert key within current word - 622 var print?/eax: boolean <- real-grapheme? key - 623 $process-sandbox-rename:real-grapheme: { - 624 compare print?, 0 # false - 625 break-if-= - 626 var new-name/eax: (addr word) <- lookup *new-name-ah - 627 add-grapheme-to-word new-name, key - 628 break $process-sandbox-rename:body - 629 } - 630 # silently ignore other hotkeys - 631 } - 632 } - 633 - 634 # collect new name in partial-name-for-function, and then define the last line - 635 # of the sandbox to be a new function with that name. Replace the last line - 636 # with a call to the appropriate function. - 637 # Precondition: cursor-call-path is a singleton (not within a call) - 638 fn process-sandbox-define _sandbox: (addr sandbox), functions: (addr handle function), key: grapheme { - 639 $process-sandbox-define:body: { - 640 var sandbox/esi: (addr sandbox) <- copy _sandbox - 641 var new-name-ah/edi: (addr handle word) <- get sandbox, partial-name-for-function - 642 # if 'esc' pressed, cancel define - 643 compare key, 0x1b # esc - 644 $process-sandbox-define:cancel: { - 645 break-if-!= - 646 var empty: (handle word) - 647 copy-handle empty, new-name-ah - 648 break $process-sandbox-define:body - 649 } - 650 # if 'enter' pressed, perform define - 651 compare key, 0xa # enter - 652 $process-sandbox-define:commit: { - 653 break-if-!= - 654 #? print-string 0, "define\n" - 655 # create new function - 656 var new-function: (handle function) - 657 var new-function-ah/ecx: (addr handle function) <- address new-function - 658 allocate new-function-ah - 659 var _new-function/eax: (addr function) <- lookup *new-function-ah - 660 var new-function/ebx: (addr function) <- copy _new-function - 661 var dest/edx: (addr handle function) <- get new-function, next - 662 copy-object functions, dest - 663 copy-object new-function-ah, functions - 664 # set function name to new-name - 665 var new-name/eax: (addr word) <- lookup *new-name-ah - 666 var dest/edx: (addr handle array byte) <- get new-function, name - 667 word-to-string new-name, dest - 668 # move final line to body - 669 var body-ah/eax: (addr handle line) <- get new-function, body - 670 allocate body-ah - 671 var body/eax: (addr line) <- lookup *body-ah - 672 var body-contents/ecx: (addr handle word) <- get body, data - 673 var final-line-storage: (handle line) - 674 var final-line-ah/eax: (addr handle line) <- address final-line-storage - 675 final-line sandbox, final-line-ah - 676 var final-line/eax: (addr line) <- lookup *final-line-ah - 677 var final-line-contents/eax: (addr handle word) <- get final-line, data - 678 copy-object final-line-contents, body-contents - 679 # - 680 copy-unbound-words-to-args functions - 681 # + 525 clear-object new-name-ah + 526 break $process-sandbox-rename:body + 527 } + 528 # if 'enter' pressed, perform rename + 529 compare key, 0xa # enter + 530 $process-sandbox-rename:commit: { + 531 break-if-!= + 532 #? print-string 0, "rename\n" + 533 # new line + 534 var new-line-h: (handle line) + 535 var new-line-ah/eax: (addr handle line) <- address new-line-h + 536 allocate new-line-ah + 537 var new-line/eax: (addr line) <- lookup *new-line-ah + 538 initialize-line new-line + 539 var new-line-word-ah/ecx: (addr handle word) <- get new-line, data + 540 { + 541 # move word at cursor to new line + 542 var cursor-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path + 543 var cursor/eax: (addr call-path-element) <- lookup *cursor-ah + 544 var word-at-cursor-ah/eax: (addr handle word) <- get cursor, word + 545 #? print-string 0, "cursor before at word " + 546 #? { + 547 #? var cursor-word/eax: (addr word) <- lookup *word-at-cursor-ah + 548 #? print-word 0, cursor-word + 549 #? print-string 0, "\n" + 550 #? } + 551 move-word-contents word-at-cursor-ah, new-line-word-ah + 552 # copy name to word at cursor + 553 copy-word-contents-before-cursor new-name-ah, word-at-cursor-ah + 554 #? print-string 0, "cursor after at word " + 555 #? { + 556 #? var cursor-word/eax: (addr word) <- lookup *word-at-cursor-ah + 557 #? print-word 0, cursor-word + 558 #? print-string 0, "\n" + 559 #? var foo/eax: int <- copy cursor-word + 560 #? print-int32-hex 0, foo + 561 #? print-string 0, "\n" + 562 #? } + 563 #? print-string 0, "new name word " + 564 #? { + 565 #? var new-name/eax: (addr word) <- lookup *new-name-ah + 566 #? print-word 0, new-name + 567 #? print-string 0, "\n" + 568 #? var foo/eax: int <- copy new-name + 569 #? print-int32-hex 0, foo + 570 #? print-string 0, "\n" + 571 #? } + 572 } + 573 # prepend '=' to name + 574 { + 575 var new-name/eax: (addr word) <- lookup *new-name-ah + 576 cursor-to-start new-name + 577 add-grapheme-to-word new-name, 0x3d # '=' + 578 } + 579 # append name to new line + 580 chain-words new-line-word-ah, new-name-ah + 581 # new-line->next = sandbox->data + 582 var new-line-next/ecx: (addr handle line) <- get new-line, next + 583 var sandbox-slot/edx: (addr handle line) <- get sandbox, data + 584 copy-object sandbox-slot, new-line-next + 585 # sandbox->data = new-line + 586 copy-handle new-line-h, sandbox-slot + 587 # clear partial-name-for-cursor-word + 588 clear-object new-name-ah + 589 #? var cursor-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path + 590 #? var cursor/eax: (addr call-path-element) <- lookup *cursor-ah + 591 #? var word-at-cursor-ah/eax: (addr handle word) <- get cursor, word + 592 #? print-string 0, "cursor after rename: " + 593 #? { + 594 #? var cursor-word/eax: (addr word) <- lookup *word-at-cursor-ah + 595 #? print-word 0, cursor-word + 596 #? print-string 0, " -- " + 597 #? var foo/eax: int <- copy cursor-word + 598 #? print-int32-hex 0, foo + 599 #? print-string 0, "\n" + 600 #? } + 601 break $process-sandbox-rename:body + 602 } + 603 # + 604 compare key, 0x7f # del (backspace on Macs) + 605 $process-sandbox-rename:backspace: { + 606 break-if-!= + 607 # if not at start, delete grapheme before cursor + 608 var new-name/eax: (addr word) <- lookup *new-name-ah + 609 var at-start?/eax: boolean <- cursor-at-start? new-name + 610 compare at-start?, 0 # false + 611 { + 612 break-if-!= + 613 var new-name/eax: (addr word) <- lookup *new-name-ah + 614 delete-before-cursor new-name + 615 } + 616 break $process-sandbox-rename:body + 617 } + 618 # otherwise insert key within current word + 619 var print?/eax: boolean <- real-grapheme? key + 620 $process-sandbox-rename:real-grapheme: { + 621 compare print?, 0 # false + 622 break-if-= + 623 var new-name/eax: (addr word) <- lookup *new-name-ah + 624 add-grapheme-to-word new-name, key + 625 break $process-sandbox-rename:body + 626 } + 627 # silently ignore other hotkeys + 628 } + 629 } + 630 + 631 # collect new name in partial-name-for-function, and then define the last line + 632 # of the sandbox to be a new function with that name. Replace the last line + 633 # with a call to the appropriate function. + 634 # Precondition: cursor-call-path is a singleton (not within a call) + 635 fn process-sandbox-define _sandbox: (addr sandbox), functions: (addr handle function), key: grapheme { + 636 $process-sandbox-define:body: { + 637 var sandbox/esi: (addr sandbox) <- copy _sandbox + 638 var new-name-ah/edi: (addr handle word) <- get sandbox, partial-name-for-function + 639 # if 'esc' pressed, cancel define + 640 compare key, 0x1b # esc + 641 $process-sandbox-define:cancel: { + 642 break-if-!= + 643 clear-object new-name-ah + 644 break $process-sandbox-define:body + 645 } + 646 # if 'enter' pressed, perform define + 647 compare key, 0xa # enter + 648 $process-sandbox-define:commit: { + 649 break-if-!= + 650 #? print-string 0, "define\n" + 651 # create new function + 652 var new-function: (handle function) + 653 var new-function-ah/ecx: (addr handle function) <- address new-function + 654 allocate new-function-ah + 655 var _new-function/eax: (addr function) <- lookup *new-function-ah + 656 var new-function/ebx: (addr function) <- copy _new-function + 657 var dest/edx: (addr handle function) <- get new-function, next + 658 copy-object functions, dest + 659 copy-object new-function-ah, functions + 660 # set function name to new-name + 661 var new-name/eax: (addr word) <- lookup *new-name-ah + 662 var dest/edx: (addr handle array byte) <- get new-function, name + 663 word-to-string new-name, dest + 664 # move final line to body + 665 var body-ah/eax: (addr handle line) <- get new-function, body + 666 allocate body-ah + 667 var body/eax: (addr line) <- lookup *body-ah + 668 var body-contents/ecx: (addr handle word) <- get body, data + 669 var final-line-storage: (handle line) + 670 var final-line-ah/eax: (addr handle line) <- address final-line-storage + 671 final-line sandbox, final-line-ah + 672 var final-line/eax: (addr line) <- lookup *final-line-ah + 673 var final-line-contents/eax: (addr handle word) <- get final-line, data + 674 copy-object final-line-contents, body-contents + 675 # + 676 copy-unbound-words-to-args functions + 677 # + 678 var empty-word: (handle word) + 679 copy-handle empty-word, final-line-contents + 680 construct-call functions, final-line-contents + 681 # clear partial-name-for-function 682 var empty-word: (handle word) - 683 copy-handle empty-word, final-line-contents - 684 construct-call functions, final-line-contents - 685 # clear partial-name-for-function - 686 var empty-word: (handle word) - 687 copy-handle empty-word, new-name-ah - 688 # update cursor - 689 var final-line/eax: (addr line) <- lookup final-line-storage - 690 var cursor-call-path-ah/ecx: (addr handle call-path-element) <- get sandbox, cursor-call-path - 691 allocate cursor-call-path-ah # leak - 692 initialize-path-from-line final-line, cursor-call-path-ah - 693 break $process-sandbox-define:body - 694 } - 695 # - 696 compare key, 0x7f # del (backspace on Macs) - 697 $process-sandbox-define:backspace: { - 698 break-if-!= - 699 # if not at start, delete grapheme before cursor - 700 var new-name/eax: (addr word) <- lookup *new-name-ah - 701 var at-start?/eax: boolean <- cursor-at-start? new-name - 702 compare at-start?, 0 # false - 703 { - 704 break-if-!= - 705 var new-name/eax: (addr word) <- lookup *new-name-ah - 706 delete-before-cursor new-name - 707 } - 708 break $process-sandbox-define:body - 709 } - 710 # otherwise insert key within current word - 711 var print?/eax: boolean <- real-grapheme? key - 712 $process-sandbox-define:real-grapheme: { - 713 compare print?, 0 # false - 714 break-if-= - 715 var new-name/eax: (addr word) <- lookup *new-name-ah - 716 add-grapheme-to-word new-name, key - 717 break $process-sandbox-define:body - 718 } - 719 # silently ignore other hotkeys - 720 } - 721 } - 722 - 723 # extract from the body of the first function in 'functions' all words that - 724 # aren't defined in the rest of 'functions'. Prepend them in reverse order. - 725 # Assumes function body is a single line for now. - 726 fn copy-unbound-words-to-args _functions: (addr handle function) { - 727 # target - 728 var target-ah/eax: (addr handle function) <- copy _functions - 729 var _target/eax: (addr function) <- lookup *target-ah - 730 var target/esi: (addr function) <- copy _target - 731 var dest-ah/edi: (addr handle word) <- get target, args - 732 # next - 733 var functions-ah/edx: (addr handle function) <- get target, next - 734 # src - 735 var line-ah/eax: (addr handle line) <- get target, body - 736 var line/eax: (addr line) <- lookup *line-ah - 737 var curr-ah/eax: (addr handle word) <- get line, data - 738 var curr/eax: (addr word) <- lookup *curr-ah - 739 { - 740 compare curr, 0 - 741 break-if-= - 742 $copy-unbound-words-to-args:loop-iter: { - 743 # is it a number? - 744 { - 745 var is-int?/eax: boolean <- word-is-decimal-integer? curr - 746 compare is-int?, 0 # false - 747 break-if-!= $copy-unbound-words-to-args:loop-iter - 748 } - 749 # is it a pre-existing function? - 750 var bound?/ebx: boolean <- bound-function? curr, functions-ah - 751 compare bound?, 0 # false - 752 break-if-!= - 753 # is it already bound as an arg? - 754 var dup?/ebx: boolean <- arg-exists? _functions, curr # _functions = target-ah - 755 compare dup?, 0 # false - 756 break-if-!= $copy-unbound-words-to-args:loop-iter - 757 # push copy of curr before dest-ah - 758 var rest-h: (handle word) - 759 var rest-ah/ecx: (addr handle word) <- address rest-h - 760 copy-object dest-ah, rest-ah - 761 copy-word curr, dest-ah - 762 chain-words dest-ah, rest-ah - 763 } - 764 var next-ah/ecx: (addr handle word) <- get curr, next - 765 curr <- lookup *next-ah - 766 loop - 767 } - 768 } - 769 - 770 fn bound-function? w: (addr word), functions-ah: (addr handle function) -> _/ebx: boolean { - 771 var result/ebx: boolean <- copy 1 # true - 772 { - 773 ## numbers - 774 # if w == "+" return true - 775 var subresult/eax: boolean <- word-equal? w, "+" + 683 copy-handle empty-word, new-name-ah + 684 # update cursor + 685 var final-line/eax: (addr line) <- lookup final-line-storage + 686 var cursor-call-path-ah/ecx: (addr handle call-path-element) <- get sandbox, cursor-call-path + 687 allocate cursor-call-path-ah # leak + 688 initialize-path-from-line final-line, cursor-call-path-ah + 689 break $process-sandbox-define:body + 690 } + 691 # + 692 compare key, 0x7f # del (backspace on Macs) + 693 $process-sandbox-define:backspace: { + 694 break-if-!= + 695 # if not at start, delete grapheme before cursor + 696 var new-name/eax: (addr word) <- lookup *new-name-ah + 697 var at-start?/eax: boolean <- cursor-at-start? new-name + 698 compare at-start?, 0 # false + 699 { + 700 break-if-!= + 701 var new-name/eax: (addr word) <- lookup *new-name-ah + 702 delete-before-cursor new-name + 703 } + 704 break $process-sandbox-define:body + 705 } + 706 # otherwise insert key within current word + 707 var print?/eax: boolean <- real-grapheme? key + 708 $process-sandbox-define:real-grapheme: { + 709 compare print?, 0 # false + 710 break-if-= + 711 var new-name/eax: (addr word) <- lookup *new-name-ah + 712 add-grapheme-to-word new-name, key + 713 break $process-sandbox-define:body + 714 } + 715 # silently ignore other hotkeys + 716 } + 717 } + 718 + 719 # extract from the body of the first function in 'functions' all words that + 720 # aren't defined in the rest of 'functions'. Prepend them in reverse order. + 721 # Assumes function body is a single line for now. + 722 fn copy-unbound-words-to-args _functions: (addr handle function) { + 723 # target + 724 var target-ah/eax: (addr handle function) <- copy _functions + 725 var _target/eax: (addr function) <- lookup *target-ah + 726 var target/esi: (addr function) <- copy _target + 727 var dest-ah/edi: (addr handle word) <- get target, args + 728 # next + 729 var functions-ah/edx: (addr handle function) <- get target, next + 730 # src + 731 var line-ah/eax: (addr handle line) <- get target, body + 732 var line/eax: (addr line) <- lookup *line-ah + 733 var curr-ah/eax: (addr handle word) <- get line, data + 734 var curr/eax: (addr word) <- lookup *curr-ah + 735 { + 736 compare curr, 0 + 737 break-if-= + 738 $copy-unbound-words-to-args:loop-iter: { + 739 # is it a number? + 740 { + 741 var is-int?/eax: boolean <- word-is-decimal-integer? curr + 742 compare is-int?, 0 # false + 743 break-if-!= $copy-unbound-words-to-args:loop-iter + 744 } + 745 # is it a pre-existing function? + 746 var bound?/ebx: boolean <- bound-function? curr, functions-ah + 747 compare bound?, 0 # false + 748 break-if-!= + 749 # is it already bound as an arg? + 750 var dup?/ebx: boolean <- arg-exists? _functions, curr # _functions = target-ah + 751 compare dup?, 0 # false + 752 break-if-!= $copy-unbound-words-to-args:loop-iter + 753 # push copy of curr before dest-ah + 754 var rest-h: (handle word) + 755 var rest-ah/ecx: (addr handle word) <- address rest-h + 756 copy-object dest-ah, rest-ah + 757 copy-word curr, dest-ah + 758 chain-words dest-ah, rest-ah + 759 } + 760 var next-ah/ecx: (addr handle word) <- get curr, next + 761 curr <- lookup *next-ah + 762 loop + 763 } + 764 } + 765 + 766 fn bound-function? w: (addr word), functions-ah: (addr handle function) -> _/ebx: boolean { + 767 var result/ebx: boolean <- copy 1 # true + 768 { + 769 ## numbers + 770 # if w == "+" return true + 771 var subresult/eax: boolean <- word-equal? w, "+" + 772 compare subresult, 0 # false + 773 break-if-!= + 774 # if w == "-" return true + 775 subresult <- word-equal? w, "-" 776 compare subresult, 0 # false 777 break-if-!= - 778 # if w == "-" return true - 779 subresult <- word-equal? w, "-" + 778 # if w == "*" return true + 779 subresult <- word-equal? w, "*" 780 compare subresult, 0 # false 781 break-if-!= - 782 # if w == "*" return true - 783 subresult <- word-equal? w, "*" - 784 compare subresult, 0 # false - 785 break-if-!= - 786 ## strings/arrays - 787 # if w == "len" return true - 788 subresult <- word-equal? w, "len" - 789 compare subresult, 0 # false - 790 break-if-!= - 791 ## files - 792 # if w == "open" return true - 793 subresult <- word-equal? w, "open" + 782 ## strings/arrays + 783 # if w == "len" return true + 784 subresult <- word-equal? w, "len" + 785 compare subresult, 0 # false + 786 break-if-!= + 787 ## files + 788 # if w == "open" return true + 789 subresult <- word-equal? w, "open" + 790 compare subresult, 0 # false + 791 break-if-!= + 792 # if w == "read" return true + 793 subresult <- word-equal? w, "read" 794 compare subresult, 0 # false 795 break-if-!= - 796 # if w == "read" return true - 797 subresult <- word-equal? w, "read" + 796 # if w == "slurp" return true + 797 subresult <- word-equal? w, "slurp" 798 compare subresult, 0 # false 799 break-if-!= - 800 # if w == "slurp" return true - 801 subresult <- word-equal? w, "slurp" + 800 # if w == "lines" return true + 801 subresult <- word-equal? w, "lines" 802 compare subresult, 0 # false 803 break-if-!= - 804 # if w == "lines" return true - 805 subresult <- word-equal? w, "lines" - 806 compare subresult, 0 # false - 807 break-if-!= - 808 ## screens - 809 # if w == "fake-screen" return true - 810 subresult <- word-equal? w, "fake-screen" + 804 ## screens + 805 # if w == "fake-screen" return true + 806 subresult <- word-equal? w, "fake-screen" + 807 compare subresult, 0 # false + 808 break-if-!= + 809 # if w == "print" return true + 810 subresult <- word-equal? w, "print" 811 compare subresult, 0 # false 812 break-if-!= - 813 # if w == "print" return true - 814 subresult <- word-equal? w, "print" + 813 # if w == "move" return true + 814 subresult <- word-equal? w, "move" 815 compare subresult, 0 # false 816 break-if-!= - 817 # if w == "move" return true - 818 subresult <- word-equal? w, "move" + 817 # if w == "up" return true + 818 subresult <- word-equal? w, "up" 819 compare subresult, 0 # false 820 break-if-!= - 821 # if w == "up" return true - 822 subresult <- word-equal? w, "up" + 821 # if w == "down" return true + 822 subresult <- word-equal? w, "down" 823 compare subresult, 0 # false 824 break-if-!= - 825 # if w == "down" return true - 826 subresult <- word-equal? w, "down" + 825 # if w == "left" return true + 826 subresult <- word-equal? w, "left" 827 compare subresult, 0 # false 828 break-if-!= - 829 # if w == "left" return true - 830 subresult <- word-equal? w, "left" + 829 # if w == "right" return true + 830 subresult <- word-equal? w, "right" 831 compare subresult, 0 # false 832 break-if-!= - 833 # if w == "right" return true - 834 subresult <- word-equal? w, "right" - 835 compare subresult, 0 # false - 836 break-if-!= - 837 ## hacks - 838 # if w == "dup" return true - 839 subresult <- word-equal? w, "dup" + 833 ## hacks + 834 # if w == "dup" return true + 835 subresult <- word-equal? w, "dup" + 836 compare subresult, 0 # false + 837 break-if-!= + 838 # if w == "swap" return true + 839 subresult <- word-equal? w, "swap" 840 compare subresult, 0 # false 841 break-if-!= - 842 # if w == "swap" return true - 843 subresult <- word-equal? w, "swap" - 844 compare subresult, 0 # false - 845 break-if-!= - 846 # return w in functions - 847 var out-h: (handle function) - 848 var out/eax: (addr handle function) <- address out-h - 849 callee functions-ah, w, out - 850 var found?/eax: (addr function) <- lookup *out - 851 result <- copy found? - 852 } - 853 return result - 854 } - 855 - 856 fn arg-exists? _f-ah: (addr handle function), arg: (addr word) -> _/ebx: boolean { - 857 var f-ah/eax: (addr handle function) <- copy _f-ah - 858 var f/eax: (addr function) <- lookup *f-ah - 859 var args-ah/eax: (addr handle word) <- get f, args - 860 var result/ebx: boolean <- word-exists? args-ah, arg - 861 return result - 862 } - 863 - 864 # construct a call to `f` with copies of exactly its args - 865 fn construct-call _f-ah: (addr handle function), _dest-ah: (addr handle word) { - 866 var f-ah/eax: (addr handle function) <- copy _f-ah - 867 var _f/eax: (addr function) <- lookup *f-ah - 868 var f/esi: (addr function) <- copy _f - 869 # append args in reverse - 870 var args-ah/eax: (addr handle word) <- get f, args - 871 var dest-ah/edi: (addr handle word) <- copy _dest-ah - 872 copy-words-in-reverse args-ah, dest-ah - 873 # append name - 874 var name-ah/eax: (addr handle array byte) <- get f, name - 875 var name/eax: (addr array byte) <- lookup *name-ah - 876 append-word-at-end-with dest-ah, name - 877 } - 878 - 879 fn word-index _words: (addr handle word), _n: int, out: (addr handle word) { - 880 $word-index:body: { - 881 var n/ecx: int <- copy _n - 882 { - 883 compare n, 0 - 884 break-if-!= - 885 copy-object _words, out - 886 break $word-index:body - 887 } - 888 var words-ah/eax: (addr handle word) <- copy _words - 889 var words/eax: (addr word) <- lookup *words-ah - 890 var next/eax: (addr handle word) <- get words, next - 891 n <- decrement - 892 word-index next, n, out - 893 } - 894 } - 895 - 896 fn toggle-cursor-word _sandbox: (addr sandbox) { - 897 $toggle-cursor-word:body: { - 898 var sandbox/esi: (addr sandbox) <- copy _sandbox - 899 var expanded-words/edi: (addr handle call-path) <- get sandbox, expanded-words - 900 var cursor-call-path/ecx: (addr handle call-path-element) <- get sandbox, cursor-call-path - 901 #? print-string 0, "cursor call path: " - 902 #? dump-call-path-element 0, cursor-call-path - 903 #? print-string 0, "expanded words:\n" - 904 #? dump-call-paths 0, expanded-words - 905 var already-expanded?/eax: boolean <- find-in-call-paths expanded-words, cursor-call-path - 906 compare already-expanded?, 0 # false - 907 { - 908 break-if-!= - 909 #? print-string 0, "expand\n" - 910 # if not already-expanded, insert - 911 insert-in-call-path expanded-words cursor-call-path - 912 #? print-string 0, "expanded words now:\n" - 913 #? dump-call-paths 0, expanded-words - 914 break $toggle-cursor-word:body - 915 } - 916 { - 917 break-if-= - 918 # otherwise delete - 919 delete-in-call-path expanded-words cursor-call-path - 920 } - 921 } - 922 } - 923 - 924 fn append-line _sandbox: (addr sandbox) { - 925 var sandbox/esi: (addr sandbox) <- copy _sandbox - 926 var line-ah/ecx: (addr handle line) <- get sandbox, data - 927 { - 928 var line/eax: (addr line) <- lookup *line-ah - 929 var next-line-ah/edx: (addr handle line) <- get line, next - 930 var next-line/eax: (addr line) <- lookup *next-line-ah - 931 compare next-line, 0 - 932 break-if-= - 933 line-ah <- copy next-line-ah - 934 loop - 935 } - 936 var line/eax: (addr line) <- lookup *line-ah - 937 var final-line-ah/edx: (addr handle line) <- get line, next - 938 allocate final-line-ah - 939 var final-line/eax: (addr line) <- lookup *final-line-ah - 940 initialize-line final-line - 941 var final-prev/eax: (addr handle line) <- get final-line, prev - 942 copy-object line-ah, final-prev - 943 # clear cursor - 944 var final-line/eax: (addr line) <- lookup *final-line-ah - 945 var word-ah/ecx: (addr handle word) <- get final-line, data - 946 var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path - 947 var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah - 948 var dest/eax: (addr handle word) <- get cursor-call-path, word - 949 copy-object word-ah, dest - 950 } + 842 # return w in functions + 843 var out-h: (handle function) + 844 var out/eax: (addr handle function) <- address out-h + 845 callee functions-ah, w, out + 846 var found?/eax: (addr function) <- lookup *out + 847 result <- copy found? + 848 } + 849 return result + 850 } + 851 + 852 fn arg-exists? _f-ah: (addr handle function), arg: (addr word) -> _/ebx: boolean { + 853 var f-ah/eax: (addr handle function) <- copy _f-ah + 854 var f/eax: (addr function) <- lookup *f-ah + 855 var args-ah/eax: (addr handle word) <- get f, args + 856 var result/ebx: boolean <- word-exists? args-ah, arg + 857 return result + 858 } + 859 + 860 # construct a call to `f` with copies of exactly its args + 861 fn construct-call _f-ah: (addr handle function), _dest-ah: (addr handle word) { + 862 var f-ah/eax: (addr handle function) <- copy _f-ah + 863 var _f/eax: (addr function) <- lookup *f-ah + 864 var f/esi: (addr function) <- copy _f + 865 # append args in reverse + 866 var args-ah/eax: (addr handle word) <- get f, args + 867 var dest-ah/edi: (addr handle word) <- copy _dest-ah + 868 copy-words-in-reverse args-ah, dest-ah + 869 # append name + 870 var name-ah/eax: (addr handle array byte) <- get f, name + 871 var name/eax: (addr array byte) <- lookup *name-ah + 872 append-word-at-end-with dest-ah, name + 873 } + 874 + 875 fn word-index _words: (addr handle word), _n: int, out: (addr handle word) { + 876 $word-index:body: { + 877 var n/ecx: int <- copy _n + 878 { + 879 compare n, 0 + 880 break-if-!= + 881 copy-object _words, out + 882 break $word-index:body + 883 } + 884 var words-ah/eax: (addr handle word) <- copy _words + 885 var words/eax: (addr word) <- lookup *words-ah + 886 var next/eax: (addr handle word) <- get words, next + 887 n <- decrement + 888 word-index next, n, out + 889 } + 890 } + 891 + 892 fn toggle-cursor-word _sandbox: (addr sandbox) { + 893 $toggle-cursor-word:body: { + 894 var sandbox/esi: (addr sandbox) <- copy _sandbox + 895 var expanded-words/edi: (addr handle call-path) <- get sandbox, expanded-words + 896 var cursor-call-path/ecx: (addr handle call-path-element) <- get sandbox, cursor-call-path + 897 #? print-string 0, "cursor call path: " + 898 #? dump-call-path-element 0, cursor-call-path + 899 #? print-string 0, "expanded words:\n" + 900 #? dump-call-paths 0, expanded-words + 901 var already-expanded?/eax: boolean <- find-in-call-paths expanded-words, cursor-call-path + 902 compare already-expanded?, 0 # false + 903 { + 904 break-if-!= + 905 #? print-string 0, "expand\n" + 906 # if not already-expanded, insert + 907 insert-in-call-path expanded-words cursor-call-path + 908 #? print-string 0, "expanded words now:\n" + 909 #? dump-call-paths 0, expanded-words + 910 break $toggle-cursor-word:body + 911 } + 912 { + 913 break-if-= + 914 # otherwise delete + 915 delete-in-call-path expanded-words cursor-call-path + 916 } + 917 } + 918 } + 919 + 920 fn append-line _sandbox: (addr sandbox) { + 921 var sandbox/esi: (addr sandbox) <- copy _sandbox + 922 var line-ah/ecx: (addr handle line) <- get sandbox, data + 923 { + 924 var line/eax: (addr line) <- lookup *line-ah + 925 var next-line-ah/edx: (addr handle line) <- get line, next + 926 var next-line/eax: (addr line) <- lookup *next-line-ah + 927 compare next-line, 0 + 928 break-if-= + 929 line-ah <- copy next-line-ah + 930 loop + 931 } + 932 var line/eax: (addr line) <- lookup *line-ah + 933 var final-line-ah/edx: (addr handle line) <- get line, next + 934 allocate final-line-ah + 935 var final-line/eax: (addr line) <- lookup *final-line-ah + 936 initialize-line final-line + 937 var final-prev/eax: (addr handle line) <- get final-line, prev + 938 copy-object line-ah, final-prev + 939 # clear cursor + 940 var final-line/eax: (addr line) <- lookup *final-line-ah + 941 var word-ah/ecx: (addr handle word) <- get final-line, data + 942 var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path + 943 var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah + 944 var dest/eax: (addr handle word) <- get cursor-call-path, word + 945 copy-object word-ah, dest + 946 } + 947 + 948 ############# + 949 # Visualize + 950 ############# 951 - 952 ############# - 953 # Visualize - 954 ############# - 955 - 956 fn evaluate-environment _env: (addr environment), stack: (addr value-stack) { - 957 var env/esi: (addr environment) <- copy _env - 958 # functions - 959 var functions/edx: (addr handle function) <- get env, functions - 960 # line - 961 var sandbox-ah/esi: (addr handle sandbox) <- get env, sandboxes - 962 var sandbox/eax: (addr sandbox) <- lookup *sandbox-ah - 963 var line-ah/eax: (addr handle line) <- get sandbox, data - 964 var _line/eax: (addr line) <- lookup *line-ah - 965 var line/esi: (addr line) <- copy _line - 966 evaluate functions, 0, line, 0, stack - 967 } - 968 - 969 fn render _env: (addr environment) { - 970 #? print-string 0, "== render\n" - 971 var env/esi: (addr environment) <- copy _env - 972 clear-canvas env - 973 # screen - 974 var screen-ah/eax: (addr handle screen) <- get env, screen - 975 var _screen/eax: (addr screen) <- lookup *screen-ah - 976 var screen/edi: (addr screen) <- copy _screen - 977 # repl-col - 978 var _repl-col/eax: (addr int) <- get env, code-separator-col - 979 var repl-col/ecx: int <- copy *_repl-col - 980 repl-col <- add 2 # repl-margin-left - 981 # functions - 982 var functions/edx: (addr handle function) <- get env, functions - 983 # sandbox - 984 var sandbox-ah/eax: (addr handle sandbox) <- get env, sandboxes - 985 var sandbox/eax: (addr sandbox) <- lookup *sandbox-ah - 986 # bindings - 987 var bindings-storage: table - 988 var bindings/ebx: (addr table) <- address bindings-storage - 989 initialize-table bindings, 0x10 - 990 #? print-string 0, "render-sandbox {\n" - 991 render-sandbox screen, functions, bindings, sandbox, 3, repl-col - 992 #? print-string 0, "render-sandbox }\n" - 993 } - 994 - 995 fn render-sandbox screen: (addr screen), functions: (addr handle function), bindings: (addr table), _sandbox: (addr sandbox), top-row: int, left-col: int { - 996 var sandbox/esi: (addr sandbox) <- copy _sandbox - 997 # line - 998 var curr-line-ah/eax: (addr handle line) <- get sandbox, data - 999 var _curr-line/eax: (addr line) <- lookup *curr-line-ah -1000 var curr-line/ecx: (addr line) <- copy _curr-line -1001 # -1002 var curr-row/edx: int <- copy top-row -1003 # cursor row, col -1004 var cursor-row: int -1005 var cursor-row-addr: (addr int) -1006 var tmp/eax: (addr int) <- address cursor-row -1007 copy-to cursor-row-addr, tmp -1008 var cursor-col: int -1009 var cursor-col-addr: (addr int) -1010 tmp <- address cursor-col -1011 copy-to cursor-col-addr, tmp -1012 # render all but final line without stack -1013 #? print-string 0, "render all but final line\n" -1014 { -1015 var next-line-ah/eax: (addr handle line) <- get curr-line, next -1016 var next-line/eax: (addr line) <- lookup *next-line-ah -1017 compare next-line, 0 -1018 break-if-= -1019 { -1020 var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path -1021 var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah -1022 var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word -1023 var cursor-word/eax: (addr word) <- lookup *cursor-word-ah -1024 # it's enough to pass in the first word of the path, because if the path isn't a singleton the word is guaranteed to be unique -1025 render-line-without-stack screen, curr-line, curr-row, left-col, cursor-word, cursor-row-addr, cursor-col-addr -1026 } -1027 curr-line <- copy next-line -1028 curr-row <- add 2 -1029 loop -1030 } -1031 # -1032 render-final-line-with-stack screen, functions, bindings, sandbox, curr-row, left-col, cursor-row-addr, cursor-col-addr -1033 # at most one of the following dialogs will be rendered -1034 render-rename-dialog screen, sandbox, cursor-row, cursor-col -1035 render-define-dialog screen, sandbox, cursor-row, cursor-col -1036 move-cursor screen, cursor-row, cursor-col -1037 } -1038 -1039 fn render-final-line-with-stack screen: (addr screen), functions: (addr handle function), bindings: (addr table), _sandbox: (addr sandbox), top-row: int, left-col: int, cursor-row-addr: (addr int), cursor-col-addr: (addr int) { -1040 var sandbox/esi: (addr sandbox) <- copy _sandbox -1041 # expanded-words -1042 var expanded-words/edi: (addr handle call-path) <- get sandbox, expanded-words -1043 # cursor-word -1044 var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path -1045 var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah -1046 var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word -1047 var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah -1048 var cursor-word/ebx: (addr word) <- copy _cursor-word -1049 #? print-string 0, "word at cursor: " -1050 #? print-word 0, cursor-word -1051 #? print-string 0, "\n" -1052 # cursor-call-path -1053 var cursor-call-path: (addr handle call-path-element) -1054 { -1055 var src/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path -1056 copy-to cursor-call-path, src -1057 } -1058 # first line -1059 var first-line-ah/eax: (addr handle line) <- get sandbox, data -1060 var _first-line/eax: (addr line) <- lookup *first-line-ah -1061 var first-line/edx: (addr line) <- copy _first-line -1062 # final line -1063 var final-line-storage: (handle line) -1064 var final-line-ah/eax: (addr handle line) <- address final-line-storage -1065 final-line sandbox, final-line-ah -1066 var final-line/eax: (addr line) <- lookup *final-line-ah -1067 # curr-path -1068 var curr-path-storage: (handle call-path-element) -1069 var curr-path/ecx: (addr handle call-path-element) <- address curr-path-storage -1070 allocate curr-path # leak -1071 initialize-path-from-line final-line, curr-path -1072 # -1073 var dummy/ecx: int <- render-line screen, functions, bindings, first-line, final-line, expanded-words, top-row, left-col, curr-path, cursor-word, cursor-call-path, cursor-row-addr, cursor-col-addr -1074 } -1075 -1076 fn final-line _sandbox: (addr sandbox), out: (addr handle line) { -1077 var sandbox/esi: (addr sandbox) <- copy _sandbox -1078 var curr-line-ah/ecx: (addr handle line) <- get sandbox, data -1079 { -1080 var curr-line/eax: (addr line) <- lookup *curr-line-ah -1081 var next-line-ah/edx: (addr handle line) <- get curr-line, next -1082 var next-line/eax: (addr line) <- lookup *next-line-ah -1083 compare next-line, 0 -1084 break-if-= -1085 curr-line-ah <- copy next-line-ah -1086 loop -1087 } -1088 copy-object curr-line-ah, out -1089 } -1090 -1091 fn render-rename-dialog screen: (addr screen), _sandbox: (addr sandbox), cursor-row: int, cursor-col: int { -1092 var sandbox/edi: (addr sandbox) <- copy _sandbox -1093 var rename-word-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-cursor-word -1094 var rename-word-mode?/eax: (addr word) <- lookup *rename-word-mode-ah? -1095 compare rename-word-mode?, 0 -1096 break-if-= -1097 # clear a space for the dialog -1098 var top-row/eax: int <- copy cursor-row -1099 top-row <- subtract 3 -1100 var bottom-row/ecx: int <- copy cursor-row -1101 bottom-row <- add 3 -1102 var left-col/edx: int <- copy cursor-col -1103 left-col <- subtract 0x10 -1104 var right-col/ebx: int <- copy cursor-col -1105 right-col <- add 0x10 -1106 clear-rect screen, top-row, left-col, bottom-row, right-col -1107 draw-box screen, top-row, left-col, bottom-row, right-col -1108 # render a little menu for the dialog -1109 var menu-row/ecx: int <- copy bottom-row -1110 menu-row <- decrement -1111 var menu-col/edx: int <- copy left-col -1112 menu-col <- add 2 -1113 move-cursor screen, menu-row, menu-col + 952 fn evaluate-environment _env: (addr environment), stack: (addr value-stack) { + 953 var env/esi: (addr environment) <- copy _env + 954 # functions + 955 var functions/edx: (addr handle function) <- get env, functions + 956 # line + 957 var sandbox-ah/esi: (addr handle sandbox) <- get env, sandboxes + 958 var sandbox/eax: (addr sandbox) <- lookup *sandbox-ah + 959 var line-ah/eax: (addr handle line) <- get sandbox, data + 960 var _line/eax: (addr line) <- lookup *line-ah + 961 var line/esi: (addr line) <- copy _line + 962 evaluate functions, 0, line, 0, stack + 963 } + 964 + 965 fn render _env: (addr environment) { + 966 #? print-string 0, "== render\n" + 967 var env/esi: (addr environment) <- copy _env + 968 clear-canvas env + 969 # screen + 970 var screen-ah/eax: (addr handle screen) <- get env, screen + 971 var _screen/eax: (addr screen) <- lookup *screen-ah + 972 var screen/edi: (addr screen) <- copy _screen + 973 # repl-col + 974 var _repl-col/eax: (addr int) <- get env, code-separator-col + 975 var repl-col/ecx: int <- copy *_repl-col + 976 repl-col <- add 2 # repl-margin-left + 977 # functions + 978 var functions/edx: (addr handle function) <- get env, functions + 979 # sandbox + 980 var sandbox-ah/eax: (addr handle sandbox) <- get env, sandboxes + 981 var sandbox/eax: (addr sandbox) <- lookup *sandbox-ah + 982 # bindings + 983 var bindings-storage: table + 984 var bindings/ebx: (addr table) <- address bindings-storage + 985 initialize-table bindings, 0x10 + 986 #? print-string 0, "render-sandbox {\n" + 987 render-sandbox screen, functions, bindings, sandbox, 3, repl-col + 988 #? print-string 0, "render-sandbox }\n" + 989 } + 990 + 991 fn render-sandbox screen: (addr screen), functions: (addr handle function), bindings: (addr table), _sandbox: (addr sandbox), top-row: int, left-col: int { + 992 var sandbox/esi: (addr sandbox) <- copy _sandbox + 993 # line + 994 var curr-line-ah/eax: (addr handle line) <- get sandbox, data + 995 var _curr-line/eax: (addr line) <- lookup *curr-line-ah + 996 var curr-line/ecx: (addr line) <- copy _curr-line + 997 # + 998 var curr-row/edx: int <- copy top-row + 999 # cursor row, col +1000 var cursor-row: int +1001 var cursor-row-addr: (addr int) +1002 var tmp/eax: (addr int) <- address cursor-row +1003 copy-to cursor-row-addr, tmp +1004 var cursor-col: int +1005 var cursor-col-addr: (addr int) +1006 tmp <- address cursor-col +1007 copy-to cursor-col-addr, tmp +1008 # render all but final line without stack +1009 #? print-string 0, "render all but final line\n" +1010 { +1011 var next-line-ah/eax: (addr handle line) <- get curr-line, next +1012 var next-line/eax: (addr line) <- lookup *next-line-ah +1013 compare next-line, 0 +1014 break-if-= +1015 { +1016 var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path +1017 var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah +1018 var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word +1019 var cursor-word/eax: (addr word) <- lookup *cursor-word-ah +1020 # it's enough to pass in the first word of the path, because if the path isn't a singleton the word is guaranteed to be unique +1021 render-line-without-stack screen, curr-line, curr-row, left-col, cursor-word, cursor-row-addr, cursor-col-addr +1022 } +1023 curr-line <- copy next-line +1024 curr-row <- add 2 +1025 loop +1026 } +1027 # +1028 render-final-line-with-stack screen, functions, bindings, sandbox, curr-row, left-col, cursor-row-addr, cursor-col-addr +1029 # at most one of the following dialogs will be rendered +1030 render-rename-dialog screen, sandbox, cursor-row, cursor-col +1031 render-define-dialog screen, sandbox, cursor-row, cursor-col +1032 move-cursor screen, cursor-row, cursor-col +1033 } +1034 +1035 fn render-final-line-with-stack screen: (addr screen), functions: (addr handle function), bindings: (addr table), _sandbox: (addr sandbox), top-row: int, left-col: int, cursor-row-addr: (addr int), cursor-col-addr: (addr int) { +1036 var sandbox/esi: (addr sandbox) <- copy _sandbox +1037 # expanded-words +1038 var expanded-words/edi: (addr handle call-path) <- get sandbox, expanded-words +1039 # cursor-word +1040 var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path +1041 var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah +1042 var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word +1043 var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah +1044 var cursor-word/ebx: (addr word) <- copy _cursor-word +1045 #? print-string 0, "word at cursor: " +1046 #? print-word 0, cursor-word +1047 #? print-string 0, "\n" +1048 # cursor-call-path +1049 var cursor-call-path: (addr handle call-path-element) +1050 { +1051 var src/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path +1052 copy-to cursor-call-path, src +1053 } +1054 # first line +1055 var first-line-ah/eax: (addr handle line) <- get sandbox, data +1056 var _first-line/eax: (addr line) <- lookup *first-line-ah +1057 var first-line/edx: (addr line) <- copy _first-line +1058 # final line +1059 var final-line-storage: (handle line) +1060 var final-line-ah/eax: (addr handle line) <- address final-line-storage +1061 final-line sandbox, final-line-ah +1062 var final-line/eax: (addr line) <- lookup *final-line-ah +1063 # curr-path +1064 var curr-path-storage: (handle call-path-element) +1065 var curr-path/ecx: (addr handle call-path-element) <- address curr-path-storage +1066 allocate curr-path # leak +1067 initialize-path-from-line final-line, curr-path +1068 # +1069 var dummy/ecx: int <- render-line screen, functions, bindings, first-line, final-line, expanded-words, top-row, left-col, curr-path, cursor-word, cursor-call-path, cursor-row-addr, cursor-col-addr +1070 } +1071 +1072 fn final-line _sandbox: (addr sandbox), out: (addr handle line) { +1073 var sandbox/esi: (addr sandbox) <- copy _sandbox +1074 var curr-line-ah/ecx: (addr handle line) <- get sandbox, data +1075 { +1076 var curr-line/eax: (addr line) <- lookup *curr-line-ah +1077 var next-line-ah/edx: (addr handle line) <- get curr-line, next +1078 var next-line/eax: (addr line) <- lookup *next-line-ah +1079 compare next-line, 0 +1080 break-if-= +1081 curr-line-ah <- copy next-line-ah +1082 loop +1083 } +1084 copy-object curr-line-ah, out +1085 } +1086 +1087 fn render-rename-dialog screen: (addr screen), _sandbox: (addr sandbox), cursor-row: int, cursor-col: int { +1088 var sandbox/edi: (addr sandbox) <- copy _sandbox +1089 var rename-word-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-cursor-word +1090 var rename-word-mode?/eax: (addr word) <- lookup *rename-word-mode-ah? +1091 compare rename-word-mode?, 0 +1092 break-if-= +1093 # clear a space for the dialog +1094 var top-row/eax: int <- copy cursor-row +1095 top-row <- subtract 3 +1096 var bottom-row/ecx: int <- copy cursor-row +1097 bottom-row <- add 3 +1098 var left-col/edx: int <- copy cursor-col +1099 left-col <- subtract 0x10 +1100 var right-col/ebx: int <- copy cursor-col +1101 right-col <- add 0x10 +1102 clear-rect screen, top-row, left-col, bottom-row, right-col +1103 draw-box screen, top-row, left-col, bottom-row, right-col +1104 # render a little menu for the dialog +1105 var menu-row/ecx: int <- copy bottom-row +1106 menu-row <- decrement +1107 var menu-col/edx: int <- copy left-col +1108 menu-col <- add 2 +1109 move-cursor screen, menu-row, menu-col +1110 start-reverse-video screen +1111 print-string screen, " esc " +1112 reset-formatting screen +1113 print-string screen, " cancel " 1114 start-reverse-video screen -1115 print-string screen, " esc " +1115 print-string screen, " enter " 1116 reset-formatting screen -1117 print-string screen, " cancel " -1118 start-reverse-video screen -1119 print-string screen, " enter " -1120 reset-formatting screen -1121 print-string screen, " rename " -1122 # draw the word, positioned appropriately around the cursor -1123 var start-col/ecx: int <- copy cursor-col -1124 var word-ah?/edx: (addr handle word) <- get sandbox, partial-name-for-cursor-word +1117 print-string screen, " rename " +1118 # draw the word, positioned appropriately around the cursor +1119 var start-col/ecx: int <- copy cursor-col +1120 var word-ah?/edx: (addr handle word) <- get sandbox, partial-name-for-cursor-word +1121 var word/eax: (addr word) <- lookup *word-ah? +1122 var cursor-index/eax: int <- cursor-index word +1123 start-col <- subtract cursor-index +1124 move-cursor screen, cursor-row, start-col 1125 var word/eax: (addr word) <- lookup *word-ah? -1126 var cursor-index/eax: int <- cursor-index word -1127 start-col <- subtract cursor-index -1128 move-cursor screen, cursor-row, start-col -1129 var word/eax: (addr word) <- lookup *word-ah? -1130 print-word screen, word -1131 } -1132 -1133 fn render-define-dialog screen: (addr screen), _sandbox: (addr sandbox), cursor-row: int, cursor-col: int { -1134 var sandbox/edi: (addr sandbox) <- copy _sandbox -1135 var define-function-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-function -1136 var define-function-mode?/eax: (addr word) <- lookup *define-function-mode-ah? -1137 compare define-function-mode?, 0 -1138 break-if-= -1139 # clear a space for the dialog -1140 var top-row/eax: int <- copy cursor-row -1141 top-row <- subtract 3 -1142 var bottom-row/ecx: int <- copy cursor-row -1143 bottom-row <- add 3 -1144 var left-col/edx: int <- copy cursor-col -1145 left-col <- subtract 0x10 -1146 var right-col/ebx: int <- copy cursor-col -1147 right-col <- add 0x10 -1148 clear-rect screen, top-row, left-col, bottom-row, right-col -1149 draw-box screen, top-row, left-col, bottom-row, right-col -1150 # render a little menu for the dialog -1151 var menu-row/ecx: int <- copy bottom-row -1152 menu-row <- decrement -1153 var menu-col/edx: int <- copy left-col -1154 menu-col <- add 2 -1155 move-cursor screen, menu-row, menu-col +1126 print-word screen, word +1127 } +1128 +1129 fn render-define-dialog screen: (addr screen), _sandbox: (addr sandbox), cursor-row: int, cursor-col: int { +1130 var sandbox/edi: (addr sandbox) <- copy _sandbox +1131 var define-function-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-function +1132 var define-function-mode?/eax: (addr word) <- lookup *define-function-mode-ah? +1133 compare define-function-mode?, 0 +1134 break-if-= +1135 # clear a space for the dialog +1136 var top-row/eax: int <- copy cursor-row +1137 top-row <- subtract 3 +1138 var bottom-row/ecx: int <- copy cursor-row +1139 bottom-row <- add 3 +1140 var left-col/edx: int <- copy cursor-col +1141 left-col <- subtract 0x10 +1142 var right-col/ebx: int <- copy cursor-col +1143 right-col <- add 0x10 +1144 clear-rect screen, top-row, left-col, bottom-row, right-col +1145 draw-box screen, top-row, left-col, bottom-row, right-col +1146 # render a little menu for the dialog +1147 var menu-row/ecx: int <- copy bottom-row +1148 menu-row <- decrement +1149 var menu-col/edx: int <- copy left-col +1150 menu-col <- add 2 +1151 move-cursor screen, menu-row, menu-col +1152 start-reverse-video screen +1153 print-string screen, " esc " +1154 reset-formatting screen +1155 print-string screen, " cancel " 1156 start-reverse-video screen -1157 print-string screen, " esc " +1157 print-string screen, " enter " 1158 reset-formatting screen -1159 print-string screen, " cancel " -1160 start-reverse-video screen -1161 print-string screen, " enter " -1162 reset-formatting screen -1163 print-string screen, " define " -1164 # draw the word, positioned appropriately around the cursor -1165 var start-col/ecx: int <- copy cursor-col -1166 var word-ah?/edx: (addr handle word) <- get sandbox, partial-name-for-function +1159 print-string screen, " define " +1160 # draw the word, positioned appropriately around the cursor +1161 var start-col/ecx: int <- copy cursor-col +1162 var word-ah?/edx: (addr handle word) <- get sandbox, partial-name-for-function +1163 var word/eax: (addr word) <- lookup *word-ah? +1164 var cursor-index/eax: int <- cursor-index word +1165 start-col <- subtract cursor-index +1166 move-cursor screen, cursor-row, start-col 1167 var word/eax: (addr word) <- lookup *word-ah? -1168 var cursor-index/eax: int <- cursor-index word -1169 start-col <- subtract cursor-index -1170 move-cursor screen, cursor-row, start-col -1171 var word/eax: (addr word) <- lookup *word-ah? -1172 print-word screen, word -1173 } -1174 -1175 # Render just the words in 'line'. -1176 fn render-line-without-stack screen: (addr screen), _line: (addr line), curr-row: int, left-col: int, cursor-word: (addr word), cursor-row-addr: (addr int), cursor-col-addr: (addr int) { -1177 # curr-word -1178 var line/eax: (addr line) <- copy _line -1179 var first-word-ah/eax: (addr handle word) <- get line, data -1180 var _curr-word/eax: (addr word) <- lookup *first-word-ah -1181 var curr-word/esi: (addr word) <- copy _curr-word -1182 # -1183 # loop-carried dependency -1184 var curr-col/ecx: int <- copy left-col -1185 # -1186 { -1187 compare curr-word, 0 -1188 break-if-= -1189 #? print-string 0, "-- word in penultimate lines: " -1190 #? { -1191 #? var foo/eax: int <- copy curr-word -1192 #? print-int32-hex 0, foo -1193 #? } -1194 #? print-string 0, "\n" -1195 var old-col/edx: int <- copy curr-col -1196 reset-formatting screen -1197 move-cursor screen, curr-row, curr-col -1198 print-word screen, curr-word -1199 { -1200 var max-width/eax: int <- word-length curr-word -1201 curr-col <- add max-width -1202 curr-col <- add 1 # margin-right -1203 } -1204 # cache cursor column if necessary -1205 { -1206 compare curr-word, cursor-word -1207 break-if-!= -1208 #? print-string 0, "Cursor at " -1209 #? print-int32-decimal 0, curr-row -1210 #? print-string 0, ", " -1211 #? print-int32-decimal 0, old-col -1212 #? print-string 0, "\n" -1213 #? print-string 0, "contents: " -1214 #? print-word 0, cursor-word -1215 #? print-string 0, "\n" -1216 #? { -1217 #? var foo/eax: int <- copy cursor-word -1218 #? print-int32-hex 0, foo -1219 #? print-string 0, "\n" -1220 #? } -1221 var dest/ecx: (addr int) <- copy cursor-row-addr -1222 var src/eax: int <- copy curr-row -1223 copy-to *dest, src -1224 dest <- copy cursor-col-addr -1225 copy-to *dest, old-col -1226 var cursor-index-in-word/eax: int <- cursor-index curr-word -1227 add-to *dest, cursor-index-in-word -1228 } -1229 # loop update -1230 var next-word-ah/edx: (addr handle word) <- get curr-word, next -1231 var _curr-word/eax: (addr word) <- lookup *next-word-ah -1232 curr-word <- copy _curr-word -1233 loop -1234 } -1235 } -1236 -1237 fn call-depth-at-cursor _sandbox: (addr sandbox) -> _/eax: int { -1238 var sandbox/esi: (addr sandbox) <- copy _sandbox -1239 var cursor-call-path/edi: (addr handle call-path-element) <- get sandbox, cursor-call-path -1240 var result/eax: int <- call-path-element-length cursor-call-path -1241 result <- add 2 # input-row - 1 -1242 return result -1243 } -1244 -1245 fn call-path-element-length _x: (addr handle call-path-element) -> _/eax: int { -1246 var curr-ah/ecx: (addr handle call-path-element) <- copy _x -1247 var result/edi: int <- copy 0 -1248 { -1249 var curr/eax: (addr call-path-element) <- lookup *curr-ah -1250 compare curr, 0 -1251 break-if-= -1252 curr-ah <- get curr, next -1253 result <- increment -1254 loop -1255 } -1256 return result -1257 } -1258 -1259 # Render the line of words in line, along with the state of the stack under each word. -1260 # Also render any expanded function calls using recursive calls. -1261 # -1262 # Along the way, compute the column the cursor should be positioned at (cursor-col-addr). -1263 fn render-line screen: (addr screen), functions: (addr handle function), bindings: (addr table), first-line: (addr line), _line: (addr line), expanded-words: (addr handle call-path), top-row: int, left-col: int, curr-path: (addr handle call-path-element), cursor-word: (addr word), cursor-call-path: (addr handle call-path-element), cursor-row-addr: (addr int), cursor-col-addr: (addr int) -> _/ecx: int { -1264 #? print-string 0, "render-line\n" -1265 #? dump-table bindings -1266 # curr-word -1267 var line/esi: (addr line) <- copy _line -1268 var first-word-ah/eax: (addr handle word) <- get line, data -1269 var curr-word/eax: (addr word) <- lookup *first-word-ah -1270 # -1271 # loop-carried dependency -1272 var curr-col/ecx: int <- copy left-col -1273 # -1274 { -1275 compare curr-word, 0 -1276 break-if-= -1277 #? print-string 0, "-- word " -1278 #? print-word 0, curr-word -1279 #? print-string 0, "\n" -1280 # if necessary, first render columns for subsidiary stack -1281 $render-line:subsidiary: { -1282 { -1283 #? print-string 0, "check sub\n" -1284 var display-subsidiary-stack?/eax: boolean <- find-in-call-paths expanded-words, curr-path -1285 compare display-subsidiary-stack?, 0 # false -1286 break-if-= $render-line:subsidiary -1287 } -1288 #? print-string 0, "render subsidiary stack\n" -1289 # does function exist? -1290 var callee/edi: (addr function) <- copy 0 -1291 { -1292 var callee-h: (handle function) -1293 var callee-ah/ecx: (addr handle function) <- address callee-h -1294 callee functions, curr-word, callee-ah -1295 var _callee/eax: (addr function) <- lookup *callee-ah -1296 callee <- copy _callee -1297 compare callee, 0 -1298 break-if-= $render-line:subsidiary -1299 } -1300 move-cursor screen, top-row, curr-col -1301 start-color screen, 8, 7 -1302 print-word screen, curr-word -1303 { -1304 var word-len/eax: int <- word-length curr-word -1305 curr-col <- add word-len -1306 curr-col <- add 2 -1307 increment top-row -1308 } -1309 # obtain stack at call site -1310 var stack-storage: value-stack -1311 var stack/edx: (addr value-stack) <- address stack-storage -1312 initialize-value-stack stack, 0x10 -1313 { -1314 var prev-word-ah/eax: (addr handle word) <- get curr-word, prev -1315 var prev-word/eax: (addr word) <- lookup *prev-word-ah -1316 compare prev-word, 0 -1317 break-if-= -1318 var bindings2-storage: table -1319 var bindings2/ebx: (addr table) <- address bindings2-storage -1320 deep-copy-table bindings, bindings2 -1321 evaluate functions, bindings2, first-line, prev-word, stack -1322 } -1323 # construct new bindings -1324 var callee-bindings-storage: table -1325 var callee-bindings/esi: (addr table) <- address callee-bindings-storage -1326 initialize-table callee-bindings, 0x10 -1327 bind-args callee, stack, callee-bindings -1328 # obtain body -1329 var callee-body-ah/eax: (addr handle line) <- get callee, body -1330 var callee-body/eax: (addr line) <- lookup *callee-body-ah -1331 var callee-body-first-word/edx: (addr handle word) <- get callee-body, data -1332 # - render subsidiary stack -1333 push-to-call-path-element curr-path, callee-body-first-word # leak -1334 #? print-string 0, "subsidiary {\n" -1335 #? dump-table callee-bindings -1336 #? syscall_exit -1337 curr-col <- render-line screen, functions, callee-bindings, callee-body, callee-body, expanded-words, top-row, curr-col, curr-path, cursor-word, cursor-call-path, cursor-row-addr, cursor-col-addr -1338 #? print-string 0, "}\n" -1339 drop-from-call-path-element curr-path -1340 # -1341 move-cursor screen, top-row, curr-col -1342 print-code-point screen, 0x21d7 # ⇗ -1343 # -1344 curr-col <- add 2 -1345 decrement top-row -1346 } -1347 # render main column -1348 var old-col/edx: int <- copy curr-col -1349 var bindings2-storage: table -1350 var bindings2/ebx: (addr table) <- address bindings2-storage -1351 #? print-string 0, "deep-copy {\n" -1352 deep-copy-table bindings, bindings2 -1353 #? print-string 0, "}\n" -1354 #? print-string 0, "render column {\n" -1355 curr-col <- render-column screen, functions, bindings2, first-line, line, curr-word, top-row, curr-col -1356 #? print-string 0, "}\n" -1357 # cache cursor column if necessary -1358 $render-line:cache-cursor-column: { -1359 { -1360 var found?/eax: boolean <- call-path-element-match? curr-path, cursor-call-path -1361 compare found?, 0 # false -1362 break-if-= $render-line:cache-cursor-column -1363 } -1364 var dest/edi: (addr int) <- copy cursor-row-addr -1365 { -1366 var src/eax: int <- copy top-row -1367 copy-to *dest, src -1368 } -1369 dest <- copy cursor-col-addr -1370 copy-to *dest, old-col -1371 var cursor-index-in-word/eax: int <- cursor-index curr-word -1372 add-to *dest, cursor-index-in-word -1373 } -1374 # loop update -1375 #? print-string 0, "next word\n" -1376 var next-word-ah/edx: (addr handle word) <- get curr-word, next -1377 curr-word <- lookup *next-word-ah -1378 #? { -1379 #? var foo/eax: int <- copy curr-word -1380 #? print-int32-hex 0, foo -1381 #? print-string 0, "\n" -1382 #? } -1383 increment-final-element curr-path -1384 loop -1385 } -1386 return curr-col -1387 } -1388 -1389 fn callee functions: (addr handle function), word: (addr word), out: (addr handle function) { -1390 var stream-storage: (stream byte 0x10) -1391 var stream/esi: (addr stream byte) <- address stream-storage -1392 emit-word word, stream -1393 find-function functions, stream, out -1394 } -1395 -1396 # Render: -1397 # - starting at top-row, left-col: final-word -1398 # - starting somewhere below at left-col: the stack result from interpreting first-world to final-word (inclusive) -1399 # -1400 # Return the farthest column written. -1401 fn render-column screen: (addr screen), functions: (addr handle function), bindings: (addr table), first-line: (addr line), line: (addr line), final-word: (addr word), top-row: int, left-col: int -> _/ecx: int { -1402 #? print-string 0, "render-column\n" -1403 #? dump-table bindings -1404 var max-width/esi: int <- copy 0 -1405 { -1406 # compute stack -1407 var stack: value-stack -1408 var stack-addr/edi: (addr value-stack) <- address stack -1409 initialize-value-stack stack-addr, 0x10 # max-words -1410 # copy bindings -1411 var bindings2-storage: table -1412 var bindings2/ebx: (addr table) <- address bindings2-storage -1413 #? print-string 0, "deep copy table {\n" -1414 deep-copy-table bindings, bindings2 -1415 #? print-string 0, "}\n" -1416 evaluate functions, bindings2, first-line, final-word, stack-addr -1417 # indent stack -1418 var indented-col/ebx: int <- copy left-col -1419 indented-col <- add 1 # margin-right -1420 # render stack -1421 var curr-row/edx: int <- copy top-row -1422 curr-row <- add 2 # stack-margin-top -1423 var _max-width/eax: int <- value-stack-max-width stack-addr -1424 max-width <- copy _max-width -1425 { -1426 var top-addr/ecx: (addr int) <- get stack-addr, top -1427 compare *top-addr, 0 -1428 break-if-<= -1429 decrement *top-addr -1430 var data-ah/eax: (addr handle array value) <- get stack-addr, data -1431 var data/eax: (addr array value) <- lookup *data-ah -1432 var top/ecx: int <- copy *top-addr -1433 var dest-offset/ecx: (offset value) <- compute-offset data, top -1434 var val/eax: (addr value) <- index data, dest-offset -1435 render-value-at screen, curr-row, indented-col, val, max-width -1436 var height/eax: int <- value-height val -1437 curr-row <- add height -1438 loop -1439 } -1440 } -1441 -1442 max-width <- add 2 # spaces on either side of items on the stack -1443 -1444 # render word, initialize result -1445 reset-formatting screen -1446 move-cursor screen, top-row, left-col -1447 print-word screen, final-word -1448 { -1449 var size/eax: int <- word-length final-word -1450 compare size, max-width -1451 break-if-<= -1452 max-width <- copy size -1453 } -1454 -1455 # post-process right-col -1456 var right-col/ecx: int <- copy left-col -1457 right-col <- add max-width -1458 right-col <- add 1 # margin-right -1459 #? print-int32-decimal 0, left-col -1460 #? print-string 0, " => " -1461 #? print-int32-decimal 0, right-col -1462 #? print-string 0, "\n" -1463 return right-col -1464 } -1465 -1466 fn clear-canvas _env: (addr environment) { -1467 var env/esi: (addr environment) <- copy _env -1468 var screen-ah/edi: (addr handle screen) <- get env, screen -1469 var _screen/eax: (addr screen) <- lookup *screen-ah -1470 var screen/edi: (addr screen) <- copy _screen -1471 clear-screen screen -1472 var nrows/eax: (addr int) <- get env, nrows -1473 var _repl-col/ecx: (addr int) <- get env, code-separator-col -1474 var repl-col/ecx: int <- copy *_repl-col -1475 draw-vertical-line screen, 1, *nrows, repl-col -1476 # wordstar-style cheatsheet of shortcuts -1477 move-cursor screen, *nrows, 0 -1478 start-reverse-video screen -1479 print-string screen, " ctrl-q " -1480 reset-formatting screen -1481 print-string screen, " quit " -1482 var menu-start/ebx: int <- copy repl-col -1483 menu-start <- subtract 0x40 # 64 = half the size of the menu -1484 move-cursor screen, *nrows, menu-start +1168 print-word screen, word +1169 } +1170 +1171 # Render just the words in 'line'. +1172 fn render-line-without-stack screen: (addr screen), _line: (addr line), curr-row: int, left-col: int, cursor-word: (addr word), cursor-row-addr: (addr int), cursor-col-addr: (addr int) { +1173 # curr-word +1174 var line/eax: (addr line) <- copy _line +1175 var first-word-ah/eax: (addr handle word) <- get line, data +1176 var _curr-word/eax: (addr word) <- lookup *first-word-ah +1177 var curr-word/esi: (addr word) <- copy _curr-word +1178 # +1179 # loop-carried dependency +1180 var curr-col/ecx: int <- copy left-col +1181 # +1182 { +1183 compare curr-word, 0 +1184 break-if-= +1185 #? print-string 0, "-- word in penultimate lines: " +1186 #? { +1187 #? var foo/eax: int <- copy curr-word +1188 #? print-int32-hex 0, foo +1189 #? } +1190 #? print-string 0, "\n" +1191 var old-col/edx: int <- copy curr-col +1192 reset-formatting screen +1193 move-cursor screen, curr-row, curr-col +1194 print-word screen, curr-word +1195 { +1196 var max-width/eax: int <- word-length curr-word +1197 curr-col <- add max-width +1198 curr-col <- add 1 # margin-right +1199 } +1200 # cache cursor column if necessary +1201 { +1202 compare curr-word, cursor-word +1203 break-if-!= +1204 #? print-string 0, "Cursor at " +1205 #? print-int32-decimal 0, curr-row +1206 #? print-string 0, ", " +1207 #? print-int32-decimal 0, old-col +1208 #? print-string 0, "\n" +1209 #? print-string 0, "contents: " +1210 #? print-word 0, cursor-word +1211 #? print-string 0, "\n" +1212 #? { +1213 #? var foo/eax: int <- copy cursor-word +1214 #? print-int32-hex 0, foo +1215 #? print-string 0, "\n" +1216 #? } +1217 var dest/ecx: (addr int) <- copy cursor-row-addr +1218 var src/eax: int <- copy curr-row +1219 copy-to *dest, src +1220 dest <- copy cursor-col-addr +1221 copy-to *dest, old-col +1222 var cursor-index-in-word/eax: int <- cursor-index curr-word +1223 add-to *dest, cursor-index-in-word +1224 } +1225 # loop update +1226 var next-word-ah/edx: (addr handle word) <- get curr-word, next +1227 var _curr-word/eax: (addr word) <- lookup *next-word-ah +1228 curr-word <- copy _curr-word +1229 loop +1230 } +1231 } +1232 +1233 fn call-depth-at-cursor _sandbox: (addr sandbox) -> _/eax: int { +1234 var sandbox/esi: (addr sandbox) <- copy _sandbox +1235 var cursor-call-path/edi: (addr handle call-path-element) <- get sandbox, cursor-call-path +1236 var result/eax: int <- call-path-element-length cursor-call-path +1237 result <- add 2 # input-row - 1 +1238 return result +1239 } +1240 +1241 fn call-path-element-length _x: (addr handle call-path-element) -> _/eax: int { +1242 var curr-ah/ecx: (addr handle call-path-element) <- copy _x +1243 var result/edi: int <- copy 0 +1244 { +1245 var curr/eax: (addr call-path-element) <- lookup *curr-ah +1246 compare curr, 0 +1247 break-if-= +1248 curr-ah <- get curr, next +1249 result <- increment +1250 loop +1251 } +1252 return result +1253 } +1254 +1255 # Render the line of words in line, along with the state of the stack under each word. +1256 # Also render any expanded function calls using recursive calls. +1257 # +1258 # Along the way, compute the column the cursor should be positioned at (cursor-col-addr). +1259 fn render-line screen: (addr screen), functions: (addr handle function), bindings: (addr table), first-line: (addr line), _line: (addr line), expanded-words: (addr handle call-path), top-row: int, left-col: int, curr-path: (addr handle call-path-element), cursor-word: (addr word), cursor-call-path: (addr handle call-path-element), cursor-row-addr: (addr int), cursor-col-addr: (addr int) -> _/ecx: int { +1260 #? print-string 0, "render-line\n" +1261 #? dump-table bindings +1262 # curr-word +1263 var line/esi: (addr line) <- copy _line +1264 var first-word-ah/eax: (addr handle word) <- get line, data +1265 var curr-word/eax: (addr word) <- lookup *first-word-ah +1266 # +1267 # loop-carried dependency +1268 var curr-col/ecx: int <- copy left-col +1269 # +1270 { +1271 compare curr-word, 0 +1272 break-if-= +1273 #? print-string 0, "-- word " +1274 #? print-word 0, curr-word +1275 #? print-string 0, "\n" +1276 # if necessary, first render columns for subsidiary stack +1277 $render-line:subsidiary: { +1278 { +1279 #? print-string 0, "check sub\n" +1280 var display-subsidiary-stack?/eax: boolean <- find-in-call-paths expanded-words, curr-path +1281 compare display-subsidiary-stack?, 0 # false +1282 break-if-= $render-line:subsidiary +1283 } +1284 #? print-string 0, "render subsidiary stack\n" +1285 # does function exist? +1286 var callee/edi: (addr function) <- copy 0 +1287 { +1288 var callee-h: (handle function) +1289 var callee-ah/ecx: (addr handle function) <- address callee-h +1290 callee functions, curr-word, callee-ah +1291 var _callee/eax: (addr function) <- lookup *callee-ah +1292 callee <- copy _callee +1293 compare callee, 0 +1294 break-if-= $render-line:subsidiary +1295 } +1296 move-cursor screen, top-row, curr-col +1297 start-color screen, 8, 7 +1298 print-word screen, curr-word +1299 { +1300 var word-len/eax: int <- word-length curr-word +1301 curr-col <- add word-len +1302 curr-col <- add 2 +1303 increment top-row +1304 } +1305 # obtain stack at call site +1306 var stack-storage: value-stack +1307 var stack/edx: (addr value-stack) <- address stack-storage +1308 initialize-value-stack stack, 0x10 +1309 { +1310 var prev-word-ah/eax: (addr handle word) <- get curr-word, prev +1311 var prev-word/eax: (addr word) <- lookup *prev-word-ah +1312 compare prev-word, 0 +1313 break-if-= +1314 var bindings2-storage: table +1315 var bindings2/ebx: (addr table) <- address bindings2-storage +1316 deep-copy-table bindings, bindings2 +1317 evaluate functions, bindings2, first-line, prev-word, stack +1318 } +1319 # construct new bindings +1320 var callee-bindings-storage: table +1321 var callee-bindings/esi: (addr table) <- address callee-bindings-storage +1322 initialize-table callee-bindings, 0x10 +1323 bind-args callee, stack, callee-bindings +1324 # obtain body +1325 var callee-body-ah/eax: (addr handle line) <- get callee, body +1326 var callee-body/eax: (addr line) <- lookup *callee-body-ah +1327 var callee-body-first-word/edx: (addr handle word) <- get callee-body, data +1328 # - render subsidiary stack +1329 push-to-call-path-element curr-path, callee-body-first-word # leak +1330 #? print-string 0, "subsidiary {\n" +1331 #? dump-table callee-bindings +1332 #? syscall_exit +1333 curr-col <- render-line screen, functions, callee-bindings, callee-body, callee-body, expanded-words, top-row, curr-col, curr-path, cursor-word, cursor-call-path, cursor-row-addr, cursor-col-addr +1334 #? print-string 0, "}\n" +1335 drop-from-call-path-element curr-path +1336 # +1337 move-cursor screen, top-row, curr-col +1338 print-code-point screen, 0x21d7 # ⇗ +1339 # +1340 curr-col <- add 2 +1341 decrement top-row +1342 } +1343 # render main column +1344 var old-col/edx: int <- copy curr-col +1345 var bindings2-storage: table +1346 var bindings2/ebx: (addr table) <- address bindings2-storage +1347 #? print-string 0, "deep-copy {\n" +1348 deep-copy-table bindings, bindings2 +1349 #? print-string 0, "}\n" +1350 #? print-string 0, "render column {\n" +1351 curr-col <- render-column screen, functions, bindings2, first-line, line, curr-word, top-row, curr-col +1352 #? print-string 0, "}\n" +1353 # cache cursor column if necessary +1354 $render-line:cache-cursor-column: { +1355 { +1356 var found?/eax: boolean <- call-path-element-match? curr-path, cursor-call-path +1357 compare found?, 0 # false +1358 break-if-= $render-line:cache-cursor-column +1359 } +1360 var dest/edi: (addr int) <- copy cursor-row-addr +1361 { +1362 var src/eax: int <- copy top-row +1363 copy-to *dest, src +1364 } +1365 dest <- copy cursor-col-addr +1366 copy-to *dest, old-col +1367 var cursor-index-in-word/eax: int <- cursor-index curr-word +1368 add-to *dest, cursor-index-in-word +1369 } +1370 # loop update +1371 #? print-string 0, "next word\n" +1372 var next-word-ah/edx: (addr handle word) <- get curr-word, next +1373 curr-word <- lookup *next-word-ah +1374 #? { +1375 #? var foo/eax: int <- copy curr-word +1376 #? print-int32-hex 0, foo +1377 #? print-string 0, "\n" +1378 #? } +1379 increment-final-element curr-path +1380 loop +1381 } +1382 return curr-col +1383 } +1384 +1385 fn callee functions: (addr handle function), word: (addr word), out: (addr handle function) { +1386 var stream-storage: (stream byte 0x10) +1387 var stream/esi: (addr stream byte) <- address stream-storage +1388 emit-word word, stream +1389 find-function functions, stream, out +1390 } +1391 +1392 # Render: +1393 # - starting at top-row, left-col: final-word +1394 # - starting somewhere below at left-col: the stack result from interpreting first-world to final-word (inclusive) +1395 # +1396 # Return the farthest column written. +1397 fn render-column screen: (addr screen), functions: (addr handle function), bindings: (addr table), first-line: (addr line), line: (addr line), final-word: (addr word), top-row: int, left-col: int -> _/ecx: int { +1398 #? print-string 0, "render-column\n" +1399 #? dump-table bindings +1400 var max-width/esi: int <- copy 0 +1401 { +1402 # compute stack +1403 var stack: value-stack +1404 var stack-addr/edi: (addr value-stack) <- address stack +1405 initialize-value-stack stack-addr, 0x10 # max-words +1406 # copy bindings +1407 var bindings2-storage: table +1408 var bindings2/ebx: (addr table) <- address bindings2-storage +1409 #? print-string 0, "deep copy table {\n" +1410 deep-copy-table bindings, bindings2 +1411 #? print-string 0, "}\n" +1412 evaluate functions, bindings2, first-line, final-word, stack-addr +1413 # indent stack +1414 var indented-col/ebx: int <- copy left-col +1415 indented-col <- add 1 # margin-right +1416 # render stack +1417 var curr-row/edx: int <- copy top-row +1418 curr-row <- add 2 # stack-margin-top +1419 var _max-width/eax: int <- value-stack-max-width stack-addr +1420 max-width <- copy _max-width +1421 { +1422 var top-addr/ecx: (addr int) <- get stack-addr, top +1423 compare *top-addr, 0 +1424 break-if-<= +1425 decrement *top-addr +1426 var data-ah/eax: (addr handle array value) <- get stack-addr, data +1427 var data/eax: (addr array value) <- lookup *data-ah +1428 var top/ecx: int <- copy *top-addr +1429 var dest-offset/ecx: (offset value) <- compute-offset data, top +1430 var val/eax: (addr value) <- index data, dest-offset +1431 render-value-at screen, curr-row, indented-col, val, max-width +1432 var height/eax: int <- value-height val +1433 curr-row <- add height +1434 loop +1435 } +1436 } +1437 +1438 max-width <- add 2 # spaces on either side of items on the stack +1439 +1440 # render word, initialize result +1441 reset-formatting screen +1442 move-cursor screen, top-row, left-col +1443 print-word screen, final-word +1444 { +1445 var size/eax: int <- word-length final-word +1446 compare size, max-width +1447 break-if-<= +1448 max-width <- copy size +1449 } +1450 +1451 # post-process right-col +1452 var right-col/ecx: int <- copy left-col +1453 right-col <- add max-width +1454 right-col <- add 1 # margin-right +1455 #? print-int32-decimal 0, left-col +1456 #? print-string 0, " => " +1457 #? print-int32-decimal 0, right-col +1458 #? print-string 0, "\n" +1459 return right-col +1460 } +1461 +1462 fn clear-canvas _env: (addr environment) { +1463 var env/esi: (addr environment) <- copy _env +1464 var screen-ah/edi: (addr handle screen) <- get env, screen +1465 var _screen/eax: (addr screen) <- lookup *screen-ah +1466 var screen/edi: (addr screen) <- copy _screen +1467 clear-screen screen +1468 var nrows/eax: (addr int) <- get env, nrows +1469 var _repl-col/ecx: (addr int) <- get env, code-separator-col +1470 var repl-col/ecx: int <- copy *_repl-col +1471 draw-vertical-line screen, 1, *nrows, repl-col +1472 # wordstar-style cheatsheet of shortcuts +1473 move-cursor screen, *nrows, 0 +1474 start-reverse-video screen +1475 print-string screen, " ctrl-q " +1476 reset-formatting screen +1477 print-string screen, " quit " +1478 var menu-start/ebx: int <- copy repl-col +1479 menu-start <- subtract 0x48 # 72 = half the size of the menu +1480 move-cursor screen, *nrows, menu-start +1481 start-reverse-video screen +1482 print-string screen, " ctrl-a " +1483 reset-formatting screen +1484 print-string screen, " ⏮ " 1485 start-reverse-video screen -1486 print-string screen, " ctrl-a " +1486 print-string screen, " ctrl-b " 1487 reset-formatting screen -1488 print-string screen, " ⏮ " +1488 print-string screen, " ◀ word " 1489 start-reverse-video screen -1490 print-string screen, " ctrl-b " +1490 print-string screen, " ctrl-f " 1491 reset-formatting screen -1492 print-string screen, " ◀ word " +1492 print-string screen, " word ▶ " 1493 start-reverse-video screen -1494 print-string screen, " ctrl-f " +1494 print-string screen, " ctrl-e " 1495 reset-formatting screen -1496 print-string screen, " word ▶ " +1496 print-string screen, " ⏭ " 1497 start-reverse-video screen -1498 print-string screen, " ctrl-e " +1498 print-string screen, " ctrl-l " 1499 reset-formatting screen -1500 print-string screen, " ⏭ " +1500 print-string screen, " new line " 1501 start-reverse-video screen 1502 print-string screen, " ctrl-u " 1503 reset-formatting screen -1504 print-string screen, " clear line " +1504 print-string screen, " clear " 1505 start-reverse-video screen 1506 print-string screen, " ctrl-n " 1507 reset-formatting screen @@ -1571,96 +1571,161 @@ if ('onhashchange' in window) { 1511 reset-formatting screen 1512 print-string screen, " define function " 1513 # primitives -1514 var start-col/ecx: int <- copy repl-col -1515 start-col <- subtract 0x28 -1516 move-cursor screen, 1, start-col -1517 print-string screen, "primitives:" -1518 start-col <- add 2 -1519 move-cursor screen, 2, start-col -1520 print-string screen, "+ - * len" -1521 move-cursor screen, 3, start-col -1522 print-string screen, "open read slurp lines" -1523 move-cursor screen, 4, start-col -1524 print-string screen, "fake-screen print move" -1525 move-cursor screen, 5, start-col -1526 print-string screen, "up down left right" -1527 move-cursor screen, 6, start-col -1528 print-string screen, "dup swap" -1529 # currently defined functions -1530 start-col <- subtract 2 -1531 move-cursor screen, 8, start-col -1532 print-string screen, "functions:" -1533 start-col <- add 2 -1534 var row/ebx: int <- copy 9 -1535 var functions/esi: (addr handle function) <- get env, functions -1536 { -1537 var curr/eax: (addr function) <- lookup *functions -1538 compare curr, 0 -1539 break-if-= -1540 row <- render-function screen, row, start-col, curr -1541 functions <- get curr, next -1542 row <- increment -1543 loop -1544 } -1545 } -1546 -1547 # only single-line functions supported for now -1548 fn render-function screen: (addr screen), row: int, col: int, _f: (addr function) -> _/ebx: int { -1549 var f/esi: (addr function) <- copy _f -1550 var args/ecx: (addr handle word) <- get f, args -1551 move-cursor screen, row, col -1552 print-words-in-reverse screen, args -1553 var name-ah/eax: (addr handle array byte) <- get f, name -1554 var name/eax: (addr array byte) <- lookup *name-ah -1555 start-bold screen -1556 print-string screen, name -1557 reset-formatting screen -1558 increment row -1559 add-to col, 2 -1560 move-cursor screen, row, col -1561 print-string screen, "= " -1562 var body-ah/eax: (addr handle line) <- get f, body -1563 var body/eax: (addr line) <- lookup *body-ah -1564 var body-words-ah/eax: (addr handle word) <- get body, data -1565 print-words screen, body-words-ah -1566 return row -1567 } -1568 -1569 fn real-grapheme? g: grapheme -> _/eax: boolean { -1570 # if g == newline return true -1571 compare g, 0xa -1572 { -1573 break-if-!= -1574 return 1 # true -1575 } -1576 # if g == tab return true -1577 compare g, 9 -1578 { -1579 break-if-!= -1580 return 1 # true -1581 } -1582 # if g < 32 return false -1583 compare g, 0x20 -1584 { -1585 break-if->= -1586 return 0 # false -1587 } -1588 # if g <= 255 return true -1589 compare g, 0xff -1590 { -1591 break-if-> -1592 return 1 # true -1593 } -1594 # if (g&0xff == Esc) it's an escape sequence -1595 and-with g, 0xff -1596 compare g, 0x1b # Esc -1597 { -1598 break-if-!= -1599 return 0 # false -1600 } -1601 # otherwise return true -1602 return 1 # true -1603 } +1514 var dummy/eax: int <- render-primitives screen, *nrows, repl-col +1515 # currently defined functions +1516 render-functions screen, repl-col, env +1517 } +1518 +1519 # return value: top-most row written to +1520 fn render-primitives screen: (addr screen), bottom-margin-row: int, right-col: int -> _/eax: int { +1521 # render primitives from the bottom of the screen upward +1522 var row/ecx: int <- copy bottom-margin-row +1523 row <- subtract 1 +1524 var col/edx: int <- copy 1 +1525 move-cursor screen, row, col +1526 row, col <- render-primitive-group screen, row, col, right-col, "numbers: ", "+ - * " +1527 row, col <- render-primitive-group screen, row, col, right-col, "arrays: ", "len " +1528 row, col <- render-primitive-group screen, row, col, right-col, "files: ", "open read slurp lines " +1529 row, col <- render-primitive-group screen, row, col, right-col, "misc: ", "dup swap " # hack: keep these at the right of the bottom row +1530 row, col <- render-primitive-group screen, row, col, right-col, "screens: ", "fake-screen print move up down left right " +1531 # finally print heading up top +1532 row <- decrement +1533 move-cursor screen, row, 1 +1534 start-bold screen +1535 print-string screen, "primitives:" +1536 reset-formatting screen +1537 return row +1538 } +1539 +1540 # start at row, col and print the given strings +1541 # move up one row if there isn't enough room before right-col +1542 # return row, col printed until +1543 fn render-primitive-group screen: (addr screen), _row: int, _col: int, right-col: int, _heading: (addr array byte), _contents: (addr array byte) -> _/ecx: int, _/edx: int { +1544 var row/ecx: int <- copy _row +1545 var col/edx: int <- copy _col +1546 # decrement row if necessary +1547 var new-col/ebx: int <- copy col +1548 var heading/esi: (addr array byte) <- copy _heading +1549 var len1/eax: int <- length heading +1550 new-col <- add len1 +1551 var contents/edi: (addr array byte) <- copy _contents +1552 var len2/eax: int <- length contents +1553 new-col <- add len2 +1554 var bound/eax: int <- copy right-col +1555 bound <- decrement +1556 { +1557 compare new-col, bound +1558 break-if-<= +1559 row <- decrement +1560 col <- copy 1 +1561 } +1562 move-cursor screen, row, col +1563 start-color screen, 0xf6, 7 +1564 print-string screen, heading +1565 reset-formatting screen +1566 print-string screen, contents +1567 return row, new-col +1568 } +1569 +1570 fn render-functions screen: (addr screen), right-col: int, _env: (addr environment) { +1571 var row/ecx: int <- copy 1 +1572 var dummy-col/edx: int <- copy right-col +1573 var env/esi: (addr environment) <- copy _env +1574 var functions/esi: (addr handle function) <- get env, functions +1575 { +1576 var curr/eax: (addr function) <- lookup *functions +1577 compare curr, 0 +1578 break-if-= +1579 row, dummy-col <- render-function-right-aligned screen, row, right-col, curr +1580 functions <- get curr, next +1581 row <- add 1 # inter-function-margin +1582 loop +1583 } +1584 } +1585 +1586 # print function starting at row, right-aligned before right-col +1587 # return row, col printed until +1588 fn render-function-right-aligned screen: (addr screen), row: int, right-col: int, f: (addr function) -> _/ecx: int, _/edx: int { +1589 var col/edx: int <- copy right-col +1590 col <- subtract 1 # function-right-margin +1591 var col2/ebx: int <- copy col +1592 var width/eax: int <- function-width f +1593 col <- subtract width +1594 var new-row/ecx: int <- copy row +1595 var height/eax: int <- function-height f +1596 new-row <- add height +1597 new-row <- decrement +1598 col <- subtract 1 # function-left-padding +1599 start-color screen, 0, 0xf7 +1600 clear-rect screen, row, col, new-row, col2 +1601 col <- add 1 +1602 #? var dummy/eax: grapheme <- read-key-from-real-keyboard +1603 render-function screen, row, col, f +1604 new-row <- add 1 # function-bottom-margin +1605 col <- subtract 1 # function-left-padding +1606 col <- subtract 1 # function-left-margin +1607 reset-formatting screen +1608 return new-row, col +1609 } +1610 +1611 # render function starting at row, col +1612 # only single-line functions supported for now +1613 fn render-function screen: (addr screen), row: int, col: int, _f: (addr function) { +1614 var f/esi: (addr function) <- copy _f +1615 var args/ecx: (addr handle word) <- get f, args +1616 move-cursor screen, row, col +1617 print-words-in-reverse screen, args +1618 var name-ah/eax: (addr handle array byte) <- get f, name +1619 var name/eax: (addr array byte) <- lookup *name-ah +1620 start-bold screen +1621 print-string screen, name +1622 reset-formatting screen +1623 start-color screen, 0, 0xf7 +1624 increment row +1625 add-to col, 2 +1626 move-cursor screen, row, col +1627 print-string screen, "≡ " +1628 var body-ah/eax: (addr handle line) <- get f, body +1629 var body/eax: (addr line) <- lookup *body-ah +1630 var body-words-ah/eax: (addr handle word) <- get body, data +1631 print-words screen, body-words-ah +1632 } +1633 +1634 fn real-grapheme? g: grapheme -> _/eax: boolean { +1635 # if g == newline return true +1636 compare g, 0xa +1637 { +1638 break-if-!= +1639 return 1 # true +1640 } +1641 # if g == tab return true +1642 compare g, 9 +1643 { +1644 break-if-!= +1645 return 1 # true +1646 } +1647 # if g < 32 return false +1648 compare g, 0x20 +1649 { +1650 break-if->= +1651 return 0 # false +1652 } +1653 # if g <= 255 return true +1654 compare g, 0xff +1655 { +1656 break-if-> +1657 return 1 # true +1658 } +1659 # if (g&0xff == Esc) it's an escape sequence +1660 and-with g, 0xff +1661 compare g, 0x1b # Esc +1662 { +1663 break-if-!= +1664 return 0 # false +1665 } +1666 # otherwise return true +1667 return 1 # true +1668 } diff --git a/html/apps/tile/rpn.mu.html b/html/apps/tile/rpn.mu.html index c67a5d75..dad0a274 100644 --- a/html/apps/tile/rpn.mu.html +++ b/html/apps/tile/rpn.mu.html @@ -141,814 +141,809 @@ if ('onhashchange' in window) { 81 var type-addr/eax: (addr int) <- get target-val, type 82 copy-to *type-addr, 0 # int 83 var target-string-ah/eax: (addr handle array byte) <- get target-val, text-data - 84 var empty: (handle array byte) - 85 copy-handle empty, target-string-ah - 86 var target/eax: (addr int) <- get target-val, int-data - 87 copy-to *target, result - 88 break $evaluate:process-word - 89 } - 90 compare *target-type-addr, 2 # array of ints - 91 { - 92 break-if-!= - 93 # compute length - 94 var src-ah/eax: (addr handle array value) <- get target-val, array-data - 95 var src/eax: (addr array value) <- lookup *src-ah - 96 var result/ebx: int <- length src - 97 # save result into target-val - 98 var type-addr/eax: (addr int) <- get target-val, type - 99 copy-to *type-addr, 0 # int -100 var target-array-ah/eax: (addr handle array value) <- get target-val, array-data -101 var empty: (handle array value) -102 copy-handle empty, target-array-ah -103 var target/eax: (addr int) <- get target-val, int-data -104 copy-to *target, result -105 break $evaluate:process-word -106 } -107 } -108 ## files -109 { -110 var is-open?/eax: boolean <- stream-data-equal? curr-stream, "open" -111 compare is-open?, 0 -112 break-if-= -113 # pop target-val from out -114 var out2/esi: (addr value-stack) <- copy out -115 var top-addr/ecx: (addr int) <- get out2, top -116 compare *top-addr, 0 -117 break-if-<= -118 var data-ah/eax: (addr handle array value) <- get out2, data -119 var data/eax: (addr array value) <- lookup *data-ah -120 var top/edx: int <- copy *top-addr -121 top <- decrement -122 var dest-offset/edx: (offset value) <- compute-offset data, top -123 var target-val/edx: (addr value) <- index data, dest-offset -124 # check target-val is a string -125 var target-type-addr/eax: (addr int) <- get target-val, type -126 compare *target-type-addr, 1 # string -127 break-if-!= -128 # open target-val as a filename and save the handle in target-val -129 var src-ah/eax: (addr handle array byte) <- get target-val, text-data -130 var src/eax: (addr array byte) <- lookup *src-ah -131 var result-ah/ecx: (addr handle buffered-file) <- get target-val, file-data -132 open src, 0, result-ah # write? = false -133 # save result into target-val -134 var type-addr/eax: (addr int) <- get target-val, type -135 copy-to *type-addr, 3 # file -136 var target-string-ah/eax: (addr handle array byte) <- get target-val, text-data -137 var filename-ah/ecx: (addr handle array byte) <- get target-val, filename -138 copy-object target-string-ah, filename-ah -139 var empty: (handle array byte) -140 copy-handle empty, target-string-ah -141 break $evaluate:process-word -142 } -143 { -144 var is-read?/eax: boolean <- stream-data-equal? curr-stream, "read" -145 compare is-read?, 0 -146 break-if-= -147 # pop target-val from out -148 var out2/esi: (addr value-stack) <- copy out -149 var top-addr/ecx: (addr int) <- get out2, top -150 compare *top-addr, 0 -151 break-if-<= -152 var data-ah/eax: (addr handle array value) <- get out2, data -153 var data/eax: (addr array value) <- lookup *data-ah -154 var top/edx: int <- copy *top-addr -155 top <- decrement -156 var dest-offset/edx: (offset value) <- compute-offset data, top -157 var target-val/edx: (addr value) <- index data, dest-offset -158 # check target-val is a file -159 var target-type-addr/eax: (addr int) <- get target-val, type -160 compare *target-type-addr, 3 # file -161 break-if-!= -162 # read a line from the file and save in target-val -163 # read target-val as a filename and save the handle in target-val -164 var file-ah/eax: (addr handle buffered-file) <- get target-val, file-data -165 var file/eax: (addr buffered-file) <- lookup *file-ah -166 var s: (stream byte 0x100) -167 var s-addr/ecx: (addr stream byte) <- address s -168 read-line-buffered file, s-addr -169 var target/eax: (addr handle array byte) <- get target-val, text-data -170 stream-to-array s-addr, target -171 # save result into target-val -172 var type-addr/eax: (addr int) <- get target-val, type -173 copy-to *type-addr, 1 # string -174 var target-file-ah/eax: (addr handle buffered-file) <- get target-val, file-data -175 var empty: (handle buffered-file) -176 copy-handle empty, target-file-ah -177 break $evaluate:process-word -178 } -179 { -180 var is-slurp?/eax: boolean <- stream-data-equal? curr-stream, "slurp" -181 compare is-slurp?, 0 -182 break-if-= -183 # pop target-val from out -184 var out2/esi: (addr value-stack) <- copy out -185 var top-addr/ecx: (addr int) <- get out2, top -186 compare *top-addr, 0 -187 break-if-<= -188 var data-ah/eax: (addr handle array value) <- get out2, data -189 var data/eax: (addr array value) <- lookup *data-ah -190 var top/edx: int <- copy *top-addr -191 top <- decrement -192 var dest-offset/edx: (offset value) <- compute-offset data, top -193 var target-val/edx: (addr value) <- index data, dest-offset -194 # check target-val is a file -195 var target-type-addr/eax: (addr int) <- get target-val, type -196 compare *target-type-addr, 3 # file -197 break-if-!= -198 # slurp all contents from file and save in target-val -199 # read target-val as a filename and save the handle in target-val -200 var file-ah/eax: (addr handle buffered-file) <- get target-val, file-data -201 var file/eax: (addr buffered-file) <- lookup *file-ah -202 var s: (stream byte 0x100) -203 var s-addr/ecx: (addr stream byte) <- address s -204 slurp file, s-addr -205 var target/eax: (addr handle array byte) <- get target-val, text-data -206 stream-to-array s-addr, target -207 # save result into target-val -208 var type-addr/eax: (addr int) <- get target-val, type -209 copy-to *type-addr, 1 # string -210 var target-file-ah/eax: (addr handle buffered-file) <- get target-val, file-data -211 var empty: (handle buffered-file) -212 copy-handle empty, target-file-ah -213 break $evaluate:process-word -214 } -215 { -216 var is-lines?/eax: boolean <- stream-data-equal? curr-stream, "lines" -217 compare is-lines?, 0 -218 break-if-= -219 # pop target-val from out -220 var out2/esi: (addr value-stack) <- copy out -221 var top-addr/ecx: (addr int) <- get out2, top -222 compare *top-addr, 0 -223 break-if-<= -224 var data-ah/eax: (addr handle array value) <- get out2, data -225 var data/eax: (addr array value) <- lookup *data-ah -226 var top/edx: int <- copy *top-addr -227 top <- decrement -228 var dest-offset/edx: (offset value) <- compute-offset data, top -229 var target-val/edx: (addr value) <- index data, dest-offset -230 # check target-val is a file -231 var target-type-addr/eax: (addr int) <- get target-val, type -232 compare *target-type-addr, 3 # file -233 break-if-!= -234 # read all lines from file and save as an array of strings in target-val -235 # read target-val as a filename and save the handle in target-val -236 var file-ah/eax: (addr handle buffered-file) <- get target-val, file-data -237 var file/eax: (addr buffered-file) <- lookup *file-ah -238 var s: (stream byte 0x100) -239 var s-addr/ecx: (addr stream byte) <- address s -240 slurp file, s-addr -241 var tmp-ah/eax: (addr handle array byte) <- get target-val, text-data -242 stream-to-array s-addr, tmp-ah -243 var tmp/eax: (addr array byte) <- lookup *tmp-ah -244 #? enable-screen-type-mode -245 #? print-string 0, tmp -246 var h: (handle array (handle array byte)) -247 { -248 var ah/edx: (addr handle array (handle array byte)) <- address h -249 split-string tmp, 0xa, ah -250 } -251 var target/eax: (addr handle array value) <- get target-val, array-data -252 save-lines h, target -253 # save result into target-val -254 var type-addr/eax: (addr int) <- get target-val, type -255 copy-to *type-addr, 2 # array -256 var target-file-ah/eax: (addr handle buffered-file) <- get target-val, file-data -257 var empty-file: (handle buffered-file) -258 copy-handle empty-file, target-file-ah -259 var target-text-ah/eax: (addr handle array byte) <- get target-val, text-data -260 var empty-text: (handle array byte) -261 copy-handle empty-text, target-text-ah -262 break $evaluate:process-word -263 } -264 ## screens -265 { -266 var is-fake-screen?/eax: boolean <- stream-data-equal? curr-stream, "fake-screen" -267 compare is-fake-screen?, 0 -268 break-if-= -269 var out2/esi: (addr value-stack) <- copy out -270 var top-addr/ecx: (addr int) <- get out2, top -271 compare *top-addr, 0 -272 break-if-<= -273 # pop width and height from out -274 var _nrows/eax: int <- pop-int-from-value-stack out2 -275 var nrows/edx: int <- copy _nrows -276 var _ncols/eax: int <- pop-int-from-value-stack out2 -277 var ncols/ebx: int <- copy _ncols -278 # define a new screen with those dimensions -279 var screen-h: (handle screen) -280 var screen-ah/eax: (addr handle screen) <- address screen-h -281 allocate screen-ah -282 var screen/eax: (addr screen) <- lookup screen-h -283 initialize-screen screen, nrows, ncols -284 # push screen to stack -285 var data-ah/eax: (addr handle array value) <- get out2, data -286 var data/eax: (addr array value) <- lookup *data-ah -287 var top/edx: int <- copy *top-addr -288 increment *top-addr -289 var dest-offset/edx: (offset value) <- compute-offset data, top -290 var target-val/edx: (addr value) <- index data, dest-offset -291 var type/eax: (addr int) <- get target-val, type -292 copy-to *type, 4 # screen -293 var dest/eax: (addr handle screen) <- get target-val, screen-data -294 copy-handle screen-h, dest -295 break $evaluate:process-word -296 } -297 { -298 var is-print?/eax: boolean <- stream-data-equal? curr-stream, "print" -299 compare is-print?, 0 -300 break-if-= -301 var out2/esi: (addr value-stack) <- copy out -302 var top-addr/ecx: (addr int) <- get out2, top -303 compare *top-addr, 0 -304 break-if-<= -305 # pop string from out -306 var top-addr/ecx: (addr int) <- get out2, top -307 compare *top-addr, 0 -308 break-if-<= -309 decrement *top-addr -310 var data-ah/eax: (addr handle array value) <- get out2, data -311 var _data/eax: (addr array value) <- lookup *data-ah -312 var data/edi: (addr array value) <- copy _data -313 var top/eax: int <- copy *top-addr -314 var dest-offset/edx: (offset value) <- compute-offset data, top -315 var s/esi: (addr value) <- index data, dest-offset -316 # select target screen from top of out (but don't pop it) -317 compare *top-addr, 0 -318 break-if-<= -319 var top/eax: int <- copy *top-addr -320 top <- decrement -321 var dest-offset/edx: (offset value) <- compute-offset data, top -322 var target-val/edx: (addr value) <- index data, dest-offset -323 var type/eax: (addr int) <- get target-val, type -324 compare *type, 4 # screen -325 break-if-!= -326 # print string to target screen -327 var dest-ah/eax: (addr handle screen) <- get target-val, screen-data -328 var dest/eax: (addr screen) <- lookup *dest-ah -329 var r/ecx: (addr int) <- get dest, cursor-row -330 var c/edx: (addr int) <- get dest, cursor-col -331 render-value-at dest, *r, *c, s, 0 -332 break $evaluate:process-word -333 } -334 { -335 var is-move?/eax: boolean <- stream-data-equal? curr-stream, "move" -336 compare is-move?, 0 -337 break-if-= -338 var out2/esi: (addr value-stack) <- copy out -339 # pop args -340 var _r/eax: int <- pop-int-from-value-stack out2 -341 var r/ecx: int <- copy _r -342 var _c/eax: int <- pop-int-from-value-stack out2 -343 var c/edx: int <- copy _c -344 # select screen from top of out (but don't pop it) -345 var top-addr/ebx: (addr int) <- get out2, top -346 compare *top-addr, 0 -347 break-if-<= -348 var data-ah/eax: (addr handle array value) <- get out2, data -349 var _data/eax: (addr array value) <- lookup *data-ah -350 var data/edi: (addr array value) <- copy _data -351 var top/eax: int <- copy *top-addr -352 top <- decrement -353 var target-offset/eax: (offset value) <- compute-offset data, top -354 var target-val/ebx: (addr value) <- index data, target-offset -355 var type/eax: (addr int) <- get target-val, type -356 compare *type, 4 # screen -357 break-if-!= -358 var target-ah/eax: (addr handle screen) <- get target-val, screen-data -359 var target/eax: (addr screen) <- lookup *target-ah -360 move-cursor target, r, c -361 break $evaluate:process-word -362 } -363 { -364 var is-up?/eax: boolean <- stream-data-equal? curr-stream, "up" -365 compare is-up?, 0 -366 break-if-= -367 var out2/esi: (addr value-stack) <- copy out -368 var top-addr/ebx: (addr int) <- get out2, top -369 compare *top-addr, 0 -370 break-if-<= -371 # pop args -372 var _d/eax: int <- pop-int-from-value-stack out2 -373 var d/ecx: int <- copy _d -374 # select screen from top of out (but don't pop it) -375 compare *top-addr, 0 -376 break-if-<= -377 var data-ah/eax: (addr handle array value) <- get out2, data -378 var _data/eax: (addr array value) <- lookup *data-ah -379 var data/edi: (addr array value) <- copy _data -380 var top/eax: int <- copy *top-addr -381 top <- decrement -382 var target-offset/eax: (offset value) <- compute-offset data, top -383 var target-val/ebx: (addr value) <- index data, target-offset -384 var type/eax: (addr int) <- get target-val, type -385 compare *type, 4 # screen -386 break-if-!= -387 var target-ah/eax: (addr handle screen) <- get target-val, screen-data -388 var _target/eax: (addr screen) <- lookup *target-ah -389 var target/edi: (addr screen) <- copy _target -390 var r/edx: (addr int) <- get target, cursor-row -391 var c/eax: (addr int) <- get target, cursor-col -392 var col/eax: int <- copy *c -393 { -394 compare d, 0 -395 break-if-<= -396 compare *r, 1 -397 break-if-<= -398 print-string target "│" -399 decrement *r -400 move-cursor target, *r, col -401 d <- decrement -402 loop -403 } -404 break $evaluate:process-word -405 } -406 { -407 var is-down?/eax: boolean <- stream-data-equal? curr-stream, "down" -408 compare is-down?, 0 -409 break-if-= -410 var out2/esi: (addr value-stack) <- copy out -411 var top-addr/ebx: (addr int) <- get out2, top -412 compare *top-addr, 0 -413 break-if-<= -414 # pop args -415 var _d/eax: int <- pop-int-from-value-stack out2 -416 var d/ecx: int <- copy _d -417 # select screen from top of out (but don't pop it) -418 compare *top-addr, 0 -419 break-if-<= -420 var data-ah/eax: (addr handle array value) <- get out2, data -421 var _data/eax: (addr array value) <- lookup *data-ah -422 var data/edi: (addr array value) <- copy _data -423 var top/eax: int <- copy *top-addr -424 top <- decrement -425 var target-offset/eax: (offset value) <- compute-offset data, top -426 var target-val/ebx: (addr value) <- index data, target-offset -427 var type/eax: (addr int) <- get target-val, type -428 compare *type, 4 # screen -429 break-if-!= -430 var target-ah/eax: (addr handle screen) <- get target-val, screen-data -431 var _target/eax: (addr screen) <- lookup *target-ah -432 var target/edi: (addr screen) <- copy _target -433 var bound-a/ebx: (addr int) <- get target, num-rows -434 var bound/ebx: int <- copy *bound-a -435 var r/edx: (addr int) <- get target, cursor-row -436 var c/eax: (addr int) <- get target, cursor-col -437 var col/eax: int <- copy *c -438 { -439 compare d, 0 -440 break-if-<= -441 compare *r, bound -442 break-if->= -443 print-string target "│" -444 increment *r -445 move-cursor target, *r, col -446 d <- decrement -447 loop -448 } -449 break $evaluate:process-word -450 } -451 { -452 var is-left?/eax: boolean <- stream-data-equal? curr-stream, "left" -453 compare is-left?, 0 -454 break-if-= -455 var out2/esi: (addr value-stack) <- copy out -456 var top-addr/ebx: (addr int) <- get out2, top -457 compare *top-addr, 0 -458 break-if-<= -459 # pop args -460 var _d/eax: int <- pop-int-from-value-stack out2 -461 var d/ecx: int <- copy _d -462 # select screen from top of out (but don't pop it) -463 compare *top-addr, 0 -464 break-if-<= -465 var data-ah/eax: (addr handle array value) <- get out2, data -466 var _data/eax: (addr array value) <- lookup *data-ah -467 var data/edi: (addr array value) <- copy _data -468 var top/eax: int <- copy *top-addr -469 top <- decrement -470 var target-offset/eax: (offset value) <- compute-offset data, top -471 var target-val/ebx: (addr value) <- index data, target-offset -472 var type/eax: (addr int) <- get target-val, type -473 compare *type, 4 # screen -474 break-if-!= -475 var target-ah/eax: (addr handle screen) <- get target-val, screen-data -476 var _target/eax: (addr screen) <- lookup *target-ah -477 var target/edi: (addr screen) <- copy _target -478 var c/edx: (addr int) <- get target, cursor-col -479 var r/eax: (addr int) <- get target, cursor-row -480 var row/eax: int <- copy *r -481 { -482 compare d, 0 -483 break-if-<= -484 compare *c, 1 -485 break-if-<= -486 print-string target "─" -487 decrement *c -488 decrement *c # second one to undo the print above -489 move-cursor target, row, *c -490 d <- decrement -491 loop -492 } -493 break $evaluate:process-word -494 } -495 { -496 var is-right?/eax: boolean <- stream-data-equal? curr-stream, "right" -497 compare is-right?, 0 -498 break-if-= -499 var out2/esi: (addr value-stack) <- copy out -500 var top-addr/ebx: (addr int) <- get out2, top -501 compare *top-addr, 0 -502 break-if-<= -503 # pop args -504 var _d/eax: int <- pop-int-from-value-stack out2 -505 var d/ecx: int <- copy _d -506 # select screen from top of out (but don't pop it) -507 compare *top-addr, 0 -508 break-if-<= -509 var data-ah/eax: (addr handle array value) <- get out2, data -510 var _data/eax: (addr array value) <- lookup *data-ah -511 var data/edi: (addr array value) <- copy _data -512 var top/eax: int <- copy *top-addr -513 top <- decrement -514 var target-offset/eax: (offset value) <- compute-offset data, top -515 var target-val/ebx: (addr value) <- index data, target-offset -516 var type/eax: (addr int) <- get target-val, type -517 compare *type, 4 # screen -518 break-if-!= -519 var target-ah/eax: (addr handle screen) <- get target-val, screen-data -520 var _target/eax: (addr screen) <- lookup *target-ah -521 var target/edi: (addr screen) <- copy _target -522 var bound-a/ebx: (addr int) <- get target, num-rows -523 var bound/ebx: int <- copy *bound-a -524 var c/edx: (addr int) <- get target, cursor-col -525 var r/eax: (addr int) <- get target, cursor-row -526 var row/eax: int <- copy *r -527 { -528 compare d, 0 -529 break-if-<= -530 compare *c, bound -531 break-if->= -532 print-string target "─" -533 # no increment; the print took care of it -534 move-cursor target, row, *c -535 d <- decrement -536 loop -537 } -538 break $evaluate:process-word -539 } -540 ## HACKS: we're trying to avoid turning this into Forth -541 { -542 var is-dup?/eax: boolean <- stream-data-equal? curr-stream, "dup" -543 compare is-dup?, 0 -544 break-if-= -545 # read src-val from out -546 var out2/esi: (addr value-stack) <- copy out -547 var top-addr/ecx: (addr int) <- get out2, top -548 compare *top-addr, 0 -549 break-if-<= -550 var data-ah/eax: (addr handle array value) <- get out2, data -551 var data/eax: (addr array value) <- lookup *data-ah -552 var top/ecx: int <- copy *top-addr -553 top <- decrement -554 var offset/edx: (offset value) <- compute-offset data, top -555 var src-val/edx: (addr value) <- index data, offset -556 # push a copy of it -557 top <- increment -558 var offset/ebx: (offset value) <- compute-offset data, top -559 var target-val/ebx: (addr value) <- index data, offset -560 copy-object src-val, target-val -561 # commit -562 var top-addr/ecx: (addr int) <- get out2, top -563 increment *top-addr -564 break $evaluate:process-word -565 } -566 { -567 var is-swap?/eax: boolean <- stream-data-equal? curr-stream, "swap" -568 compare is-swap?, 0 -569 break-if-= -570 # read top-val from out -571 var out2/esi: (addr value-stack) <- copy out -572 var top-addr/ecx: (addr int) <- get out2, top -573 compare *top-addr, 0 -574 break-if-<= -575 var data-ah/eax: (addr handle array value) <- get out2, data -576 var data/eax: (addr array value) <- lookup *data-ah -577 var top/ecx: int <- copy *top-addr -578 top <- decrement -579 var offset/edx: (offset value) <- compute-offset data, top -580 var top-val/edx: (addr value) <- index data, offset -581 # read next val from out -582 top <- decrement -583 var offset/ebx: (offset value) <- compute-offset data, top -584 var pen-top-val/ebx: (addr value) <- index data, offset -585 # swap -586 var tmp: value -587 var tmp-a/eax: (addr value) <- address tmp -588 copy-object top-val, tmp-a -589 copy-object pen-top-val, top-val -590 copy-object tmp-a, pen-top-val -591 break $evaluate:process-word -592 } -593 ### if curr-stream defines a binding, save top of stack to bindings -594 { -595 var done?/eax: boolean <- stream-empty? curr-stream -596 compare done?, 0 # false -597 break-if-!= -598 var new-byte/eax: byte <- read-byte curr-stream -599 compare new-byte, 0x3d # '=' -600 break-if-!= -601 # pop target-val from out -602 var out2/esi: (addr value-stack) <- copy out -603 var top-addr/ecx: (addr int) <- get out2, top -604 compare *top-addr, 0 -605 break-if-<= -606 var data-ah/eax: (addr handle array value) <- get out2, data -607 var data/eax: (addr array value) <- lookup *data-ah -608 var top/edx: int <- copy *top-addr -609 top <- decrement -610 var dest-offset/edx: (offset value) <- compute-offset data, top -611 var target-val/edx: (addr value) <- index data, dest-offset -612 # create binding from curr-stream to target-val -613 var key-h: (handle array byte) -614 var key/ecx: (addr handle array byte) <- address key-h -615 stream-to-array curr-stream, key -616 bind-in-table bindings, key, target-val -617 break $evaluate:process-word -618 } -619 rewind-stream curr-stream -620 ### if curr-stream is a known function name, call it appropriately -621 { -622 var callee-h: (handle function) -623 var callee-ah/eax: (addr handle function) <- address callee-h -624 find-function functions, curr-stream, callee-ah -625 var callee/eax: (addr function) <- lookup *callee-ah -626 compare callee, 0 -627 break-if-= -628 perform-call callee, out, functions -629 break $evaluate:process-word -630 } -631 ### if it's a name, push its value -632 { -633 compare bindings, 0 -634 break-if-= -635 var tmp: (handle array byte) -636 var curr-string-ah/edx: (addr handle array byte) <- address tmp -637 stream-to-array curr-stream, curr-string-ah # unfortunate leak -638 var curr-string/eax: (addr array byte) <- lookup *curr-string-ah -639 var val-storage: (handle value) -640 var val-ah/edi: (addr handle value) <- address val-storage -641 lookup-binding bindings, curr-string, val-ah -642 var val/eax: (addr value) <- lookup *val-ah -643 compare val, 0 -644 break-if-= -645 push-value-stack out, val -646 break $evaluate:process-word -647 } -648 ### if the word starts with a quote and ends with a quote, turn it into a string -649 { -650 var start/eax: byte <- stream-first curr-stream -651 compare start, 0x22 # double-quote -652 break-if-!= -653 var end/eax: byte <- stream-final curr-stream -654 compare end, 0x22 # double-quote -655 break-if-!= -656 var h: (handle array byte) -657 var s/eax: (addr handle array byte) <- address h -658 unquote-stream-to-array curr-stream, s # leak -659 push-string-to-value-stack out, *s -660 break $evaluate:process-word -661 } -662 ### if the word starts with a '[' and ends with a ']', turn it into an array -663 { -664 var start/eax: byte <- stream-first curr-stream -665 compare start, 0x5b # '[' -666 break-if-!= -667 var end/eax: byte <- stream-final curr-stream -668 compare end, 0x5d # ']' -669 break-if-!= -670 # wastefully create a new input string to strip quotes -671 var h: (handle array value) -672 var input-ah/eax: (addr handle array byte) <- address h -673 unquote-stream-to-array curr-stream, input-ah # leak -674 # wastefully parse input into int-array -675 # TODO: support parsing arrays of other types -676 var input/eax: (addr array byte) <- lookup *input-ah -677 var h2: (handle array int) -678 var int-array-ah/esi: (addr handle array int) <- address h2 -679 parse-array-of-decimal-ints input, int-array-ah # leak -680 var _int-array/eax: (addr array int) <- lookup *int-array-ah -681 var int-array/esi: (addr array int) <- copy _int-array -682 var len/ebx: int <- length int-array -683 # push value-array of same size as int-array -684 var h3: (handle array value) -685 var value-array-ah/eax: (addr handle array value) <- address h3 -686 populate value-array-ah, len -687 push-array-to-value-stack out, *value-array-ah -688 # copy int-array into value-array -689 var _value-array/eax: (addr array value) <- lookup *value-array-ah -690 var value-array/edi: (addr array value) <- copy _value-array -691 var i/eax: int <- copy 0 -692 { -693 compare i, len -694 break-if->= -695 var src-addr/ecx: (addr int) <- index int-array, i -696 var src/ecx: int <- copy *src-addr -697 var dest-offset/edx: (offset value) <- compute-offset value-array, i -698 var dest-val/edx: (addr value) <- index value-array, dest-offset -699 var dest/edx: (addr int) <- get dest-val, int-data -700 copy-to *dest, src -701 i <- increment -702 loop -703 } -704 break $evaluate:process-word + 84 clear-object target-string-ah + 85 var target/eax: (addr int) <- get target-val, int-data + 86 copy-to *target, result + 87 break $evaluate:process-word + 88 } + 89 compare *target-type-addr, 2 # array of ints + 90 { + 91 break-if-!= + 92 # compute length + 93 var src-ah/eax: (addr handle array value) <- get target-val, array-data + 94 var src/eax: (addr array value) <- lookup *src-ah + 95 var result/ebx: int <- length src + 96 # save result into target-val + 97 var type-addr/eax: (addr int) <- get target-val, type + 98 copy-to *type-addr, 0 # int + 99 var target-array-ah/eax: (addr handle array value) <- get target-val, array-data +100 clear-object target-array-ah +101 var target/eax: (addr int) <- get target-val, int-data +102 copy-to *target, result +103 break $evaluate:process-word +104 } +105 } +106 ## files +107 { +108 var is-open?/eax: boolean <- stream-data-equal? curr-stream, "open" +109 compare is-open?, 0 +110 break-if-= +111 # pop target-val from out +112 var out2/esi: (addr value-stack) <- copy out +113 var top-addr/ecx: (addr int) <- get out2, top +114 compare *top-addr, 0 +115 break-if-<= +116 var data-ah/eax: (addr handle array value) <- get out2, data +117 var data/eax: (addr array value) <- lookup *data-ah +118 var top/edx: int <- copy *top-addr +119 top <- decrement +120 var dest-offset/edx: (offset value) <- compute-offset data, top +121 var target-val/edx: (addr value) <- index data, dest-offset +122 # check target-val is a string +123 var target-type-addr/eax: (addr int) <- get target-val, type +124 compare *target-type-addr, 1 # string +125 break-if-!= +126 # open target-val as a filename and save the handle in target-val +127 var src-ah/eax: (addr handle array byte) <- get target-val, text-data +128 var src/eax: (addr array byte) <- lookup *src-ah +129 var result-ah/ecx: (addr handle buffered-file) <- get target-val, file-data +130 open src, 0, result-ah # write? = false +131 # save result into target-val +132 var type-addr/eax: (addr int) <- get target-val, type +133 copy-to *type-addr, 3 # file +134 var target-string-ah/eax: (addr handle array byte) <- get target-val, text-data +135 var filename-ah/ecx: (addr handle array byte) <- get target-val, filename +136 copy-object target-string-ah, filename-ah +137 clear-object target-string-ah +138 break $evaluate:process-word +139 } +140 { +141 var is-read?/eax: boolean <- stream-data-equal? curr-stream, "read" +142 compare is-read?, 0 +143 break-if-= +144 # pop target-val from out +145 var out2/esi: (addr value-stack) <- copy out +146 var top-addr/ecx: (addr int) <- get out2, top +147 compare *top-addr, 0 +148 break-if-<= +149 var data-ah/eax: (addr handle array value) <- get out2, data +150 var data/eax: (addr array value) <- lookup *data-ah +151 var top/edx: int <- copy *top-addr +152 top <- decrement +153 var dest-offset/edx: (offset value) <- compute-offset data, top +154 var target-val/edx: (addr value) <- index data, dest-offset +155 # check target-val is a file +156 var target-type-addr/eax: (addr int) <- get target-val, type +157 compare *target-type-addr, 3 # file +158 break-if-!= +159 # read a line from the file and save in target-val +160 # read target-val as a filename and save the handle in target-val +161 var file-ah/eax: (addr handle buffered-file) <- get target-val, file-data +162 var file/eax: (addr buffered-file) <- lookup *file-ah +163 var s: (stream byte 0x100) +164 var s-addr/ecx: (addr stream byte) <- address s +165 read-line-buffered file, s-addr +166 var target/eax: (addr handle array byte) <- get target-val, text-data +167 stream-to-array s-addr, target +168 # save result into target-val +169 var type-addr/eax: (addr int) <- get target-val, type +170 copy-to *type-addr, 1 # string +171 var target-file-ah/eax: (addr handle buffered-file) <- get target-val, file-data +172 clear-object target-file-ah +173 break $evaluate:process-word +174 } +175 { +176 var is-slurp?/eax: boolean <- stream-data-equal? curr-stream, "slurp" +177 compare is-slurp?, 0 +178 break-if-= +179 # pop target-val from out +180 var out2/esi: (addr value-stack) <- copy out +181 var top-addr/ecx: (addr int) <- get out2, top +182 compare *top-addr, 0 +183 break-if-<= +184 var data-ah/eax: (addr handle array value) <- get out2, data +185 var data/eax: (addr array value) <- lookup *data-ah +186 var top/edx: int <- copy *top-addr +187 top <- decrement +188 var dest-offset/edx: (offset value) <- compute-offset data, top +189 var target-val/edx: (addr value) <- index data, dest-offset +190 # check target-val is a file +191 var target-type-addr/eax: (addr int) <- get target-val, type +192 compare *target-type-addr, 3 # file +193 break-if-!= +194 # slurp all contents from file and save in target-val +195 # read target-val as a filename and save the handle in target-val +196 var file-ah/eax: (addr handle buffered-file) <- get target-val, file-data +197 var file/eax: (addr buffered-file) <- lookup *file-ah +198 var s: (stream byte 0x100) +199 var s-addr/ecx: (addr stream byte) <- address s +200 slurp file, s-addr +201 var target/eax: (addr handle array byte) <- get target-val, text-data +202 stream-to-array s-addr, target +203 # save result into target-val +204 var type-addr/eax: (addr int) <- get target-val, type +205 copy-to *type-addr, 1 # string +206 var target-file-ah/eax: (addr handle buffered-file) <- get target-val, file-data +207 clear-object target-file-ah +208 break $evaluate:process-word +209 } +210 { +211 var is-lines?/eax: boolean <- stream-data-equal? curr-stream, "lines" +212 compare is-lines?, 0 +213 break-if-= +214 # pop target-val from out +215 var out2/esi: (addr value-stack) <- copy out +216 var top-addr/ecx: (addr int) <- get out2, top +217 compare *top-addr, 0 +218 break-if-<= +219 var data-ah/eax: (addr handle array value) <- get out2, data +220 var data/eax: (addr array value) <- lookup *data-ah +221 var top/edx: int <- copy *top-addr +222 top <- decrement +223 var dest-offset/edx: (offset value) <- compute-offset data, top +224 var target-val/edx: (addr value) <- index data, dest-offset +225 # check target-val is a file +226 var target-type-addr/eax: (addr int) <- get target-val, type +227 compare *target-type-addr, 3 # file +228 break-if-!= +229 # read all lines from file and save as an array of strings in target-val +230 # read target-val as a filename and save the handle in target-val +231 var file-ah/eax: (addr handle buffered-file) <- get target-val, file-data +232 var file/eax: (addr buffered-file) <- lookup *file-ah +233 var s: (stream byte 0x100) +234 var s-addr/ecx: (addr stream byte) <- address s +235 slurp file, s-addr +236 var tmp-ah/eax: (addr handle array byte) <- get target-val, text-data +237 stream-to-array s-addr, tmp-ah +238 var tmp/eax: (addr array byte) <- lookup *tmp-ah +239 #? enable-screen-type-mode +240 #? print-string 0, tmp +241 var h: (handle array (handle array byte)) +242 { +243 var ah/edx: (addr handle array (handle array byte)) <- address h +244 split-string tmp, 0xa, ah +245 } +246 var target/eax: (addr handle array value) <- get target-val, array-data +247 save-lines h, target +248 # save result into target-val +249 var type-addr/eax: (addr int) <- get target-val, type +250 copy-to *type-addr, 2 # array +251 var target-file-ah/eax: (addr handle buffered-file) <- get target-val, file-data +252 var empty-file: (handle buffered-file) +253 copy-handle empty-file, target-file-ah +254 var target-text-ah/eax: (addr handle array byte) <- get target-val, text-data +255 var empty-text: (handle array byte) +256 copy-handle empty-text, target-text-ah +257 break $evaluate:process-word +258 } +259 ## screens +260 { +261 var is-fake-screen?/eax: boolean <- stream-data-equal? curr-stream, "fake-screen" +262 compare is-fake-screen?, 0 +263 break-if-= +264 var out2/esi: (addr value-stack) <- copy out +265 var top-addr/ecx: (addr int) <- get out2, top +266 compare *top-addr, 0 +267 break-if-<= +268 # pop width and height from out +269 var _nrows/eax: int <- pop-int-from-value-stack out2 +270 var nrows/edx: int <- copy _nrows +271 var _ncols/eax: int <- pop-int-from-value-stack out2 +272 var ncols/ebx: int <- copy _ncols +273 # define a new screen with those dimensions +274 var screen-h: (handle screen) +275 var screen-ah/eax: (addr handle screen) <- address screen-h +276 allocate screen-ah +277 var screen/eax: (addr screen) <- lookup screen-h +278 initialize-screen screen, nrows, ncols +279 # push screen to stack +280 var data-ah/eax: (addr handle array value) <- get out2, data +281 var data/eax: (addr array value) <- lookup *data-ah +282 var top/edx: int <- copy *top-addr +283 increment *top-addr +284 var dest-offset/edx: (offset value) <- compute-offset data, top +285 var target-val/edx: (addr value) <- index data, dest-offset +286 var type/eax: (addr int) <- get target-val, type +287 copy-to *type, 4 # screen +288 var dest/eax: (addr handle screen) <- get target-val, screen-data +289 copy-handle screen-h, dest +290 break $evaluate:process-word +291 } +292 { +293 var is-print?/eax: boolean <- stream-data-equal? curr-stream, "print" +294 compare is-print?, 0 +295 break-if-= +296 var out2/esi: (addr value-stack) <- copy out +297 var top-addr/ecx: (addr int) <- get out2, top +298 compare *top-addr, 0 +299 break-if-<= +300 # pop string from out +301 var top-addr/ecx: (addr int) <- get out2, top +302 compare *top-addr, 0 +303 break-if-<= +304 decrement *top-addr +305 var data-ah/eax: (addr handle array value) <- get out2, data +306 var _data/eax: (addr array value) <- lookup *data-ah +307 var data/edi: (addr array value) <- copy _data +308 var top/eax: int <- copy *top-addr +309 var dest-offset/edx: (offset value) <- compute-offset data, top +310 var s/esi: (addr value) <- index data, dest-offset +311 # select target screen from top of out (but don't pop it) +312 compare *top-addr, 0 +313 break-if-<= +314 var top/eax: int <- copy *top-addr +315 top <- decrement +316 var dest-offset/edx: (offset value) <- compute-offset data, top +317 var target-val/edx: (addr value) <- index data, dest-offset +318 var type/eax: (addr int) <- get target-val, type +319 compare *type, 4 # screen +320 break-if-!= +321 # print string to target screen +322 var dest-ah/eax: (addr handle screen) <- get target-val, screen-data +323 var dest/eax: (addr screen) <- lookup *dest-ah +324 var r/ecx: (addr int) <- get dest, cursor-row +325 var c/edx: (addr int) <- get dest, cursor-col +326 render-value-at dest, *r, *c, s, 0 +327 break $evaluate:process-word +328 } +329 { +330 var is-move?/eax: boolean <- stream-data-equal? curr-stream, "move" +331 compare is-move?, 0 +332 break-if-= +333 var out2/esi: (addr value-stack) <- copy out +334 # pop args +335 var _r/eax: int <- pop-int-from-value-stack out2 +336 var r/ecx: int <- copy _r +337 var _c/eax: int <- pop-int-from-value-stack out2 +338 var c/edx: int <- copy _c +339 # select screen from top of out (but don't pop it) +340 var top-addr/ebx: (addr int) <- get out2, top +341 compare *top-addr, 0 +342 break-if-<= +343 var data-ah/eax: (addr handle array value) <- get out2, data +344 var _data/eax: (addr array value) <- lookup *data-ah +345 var data/edi: (addr array value) <- copy _data +346 var top/eax: int <- copy *top-addr +347 top <- decrement +348 var target-offset/eax: (offset value) <- compute-offset data, top +349 var target-val/ebx: (addr value) <- index data, target-offset +350 var type/eax: (addr int) <- get target-val, type +351 compare *type, 4 # screen +352 break-if-!= +353 var target-ah/eax: (addr handle screen) <- get target-val, screen-data +354 var target/eax: (addr screen) <- lookup *target-ah +355 move-cursor target, r, c +356 break $evaluate:process-word +357 } +358 { +359 var is-up?/eax: boolean <- stream-data-equal? curr-stream, "up" +360 compare is-up?, 0 +361 break-if-= +362 var out2/esi: (addr value-stack) <- copy out +363 var top-addr/ebx: (addr int) <- get out2, top +364 compare *top-addr, 0 +365 break-if-<= +366 # pop args +367 var _d/eax: int <- pop-int-from-value-stack out2 +368 var d/ecx: int <- copy _d +369 # select screen from top of out (but don't pop it) +370 compare *top-addr, 0 +371 break-if-<= +372 var data-ah/eax: (addr handle array value) <- get out2, data +373 var _data/eax: (addr array value) <- lookup *data-ah +374 var data/edi: (addr array value) <- copy _data +375 var top/eax: int <- copy *top-addr +376 top <- decrement +377 var target-offset/eax: (offset value) <- compute-offset data, top +378 var target-val/ebx: (addr value) <- index data, target-offset +379 var type/eax: (addr int) <- get target-val, type +380 compare *type, 4 # screen +381 break-if-!= +382 var target-ah/eax: (addr handle screen) <- get target-val, screen-data +383 var _target/eax: (addr screen) <- lookup *target-ah +384 var target/edi: (addr screen) <- copy _target +385 var r/edx: (addr int) <- get target, cursor-row +386 var c/eax: (addr int) <- get target, cursor-col +387 var col/eax: int <- copy *c +388 { +389 compare d, 0 +390 break-if-<= +391 compare *r, 1 +392 break-if-<= +393 print-string target "│" +394 decrement *r +395 move-cursor target, *r, col +396 d <- decrement +397 loop +398 } +399 break $evaluate:process-word +400 } +401 { +402 var is-down?/eax: boolean <- stream-data-equal? curr-stream, "down" +403 compare is-down?, 0 +404 break-if-= +405 var out2/esi: (addr value-stack) <- copy out +406 var top-addr/ebx: (addr int) <- get out2, top +407 compare *top-addr, 0 +408 break-if-<= +409 # pop args +410 var _d/eax: int <- pop-int-from-value-stack out2 +411 var d/ecx: int <- copy _d +412 # select screen from top of out (but don't pop it) +413 compare *top-addr, 0 +414 break-if-<= +415 var data-ah/eax: (addr handle array value) <- get out2, data +416 var _data/eax: (addr array value) <- lookup *data-ah +417 var data/edi: (addr array value) <- copy _data +418 var top/eax: int <- copy *top-addr +419 top <- decrement +420 var target-offset/eax: (offset value) <- compute-offset data, top +421 var target-val/ebx: (addr value) <- index data, target-offset +422 var type/eax: (addr int) <- get target-val, type +423 compare *type, 4 # screen +424 break-if-!= +425 var target-ah/eax: (addr handle screen) <- get target-val, screen-data +426 var _target/eax: (addr screen) <- lookup *target-ah +427 var target/edi: (addr screen) <- copy _target +428 var bound-a/ebx: (addr int) <- get target, num-rows +429 var bound/ebx: int <- copy *bound-a +430 var r/edx: (addr int) <- get target, cursor-row +431 var c/eax: (addr int) <- get target, cursor-col +432 var col/eax: int <- copy *c +433 { +434 compare d, 0 +435 break-if-<= +436 compare *r, bound +437 break-if->= +438 print-string target "│" +439 increment *r +440 move-cursor target, *r, col +441 d <- decrement +442 loop +443 } +444 break $evaluate:process-word +445 } +446 { +447 var is-left?/eax: boolean <- stream-data-equal? curr-stream, "left" +448 compare is-left?, 0 +449 break-if-= +450 var out2/esi: (addr value-stack) <- copy out +451 var top-addr/ebx: (addr int) <- get out2, top +452 compare *top-addr, 0 +453 break-if-<= +454 # pop args +455 var _d/eax: int <- pop-int-from-value-stack out2 +456 var d/ecx: int <- copy _d +457 # select screen from top of out (but don't pop it) +458 compare *top-addr, 0 +459 break-if-<= +460 var data-ah/eax: (addr handle array value) <- get out2, data +461 var _data/eax: (addr array value) <- lookup *data-ah +462 var data/edi: (addr array value) <- copy _data +463 var top/eax: int <- copy *top-addr +464 top <- decrement +465 var target-offset/eax: (offset value) <- compute-offset data, top +466 var target-val/ebx: (addr value) <- index data, target-offset +467 var type/eax: (addr int) <- get target-val, type +468 compare *type, 4 # screen +469 break-if-!= +470 var target-ah/eax: (addr handle screen) <- get target-val, screen-data +471 var _target/eax: (addr screen) <- lookup *target-ah +472 var target/edi: (addr screen) <- copy _target +473 var c/edx: (addr int) <- get target, cursor-col +474 var r/eax: (addr int) <- get target, cursor-row +475 var row/eax: int <- copy *r +476 { +477 compare d, 0 +478 break-if-<= +479 compare *c, 1 +480 break-if-<= +481 print-string target "─" +482 decrement *c +483 decrement *c # second one to undo the print above +484 move-cursor target, row, *c +485 d <- decrement +486 loop +487 } +488 break $evaluate:process-word +489 } +490 { +491 var is-right?/eax: boolean <- stream-data-equal? curr-stream, "right" +492 compare is-right?, 0 +493 break-if-= +494 var out2/esi: (addr value-stack) <- copy out +495 var top-addr/ebx: (addr int) <- get out2, top +496 compare *top-addr, 0 +497 break-if-<= +498 # pop args +499 var _d/eax: int <- pop-int-from-value-stack out2 +500 var d/ecx: int <- copy _d +501 # select screen from top of out (but don't pop it) +502 compare *top-addr, 0 +503 break-if-<= +504 var data-ah/eax: (addr handle array value) <- get out2, data +505 var _data/eax: (addr array value) <- lookup *data-ah +506 var data/edi: (addr array value) <- copy _data +507 var top/eax: int <- copy *top-addr +508 top <- decrement +509 var target-offset/eax: (offset value) <- compute-offset data, top +510 var target-val/ebx: (addr value) <- index data, target-offset +511 var type/eax: (addr int) <- get target-val, type +512 compare *type, 4 # screen +513 break-if-!= +514 var target-ah/eax: (addr handle screen) <- get target-val, screen-data +515 var _target/eax: (addr screen) <- lookup *target-ah +516 var target/edi: (addr screen) <- copy _target +517 var bound-a/ebx: (addr int) <- get target, num-rows +518 var bound/ebx: int <- copy *bound-a +519 var c/edx: (addr int) <- get target, cursor-col +520 var r/eax: (addr int) <- get target, cursor-row +521 var row/eax: int <- copy *r +522 { +523 compare d, 0 +524 break-if-<= +525 compare *c, bound +526 break-if->= +527 print-string target "─" +528 # no increment; the print took care of it +529 move-cursor target, row, *c +530 d <- decrement +531 loop +532 } +533 break $evaluate:process-word +534 } +535 ## HACKS: we're trying to avoid turning this into Forth +536 { +537 var is-dup?/eax: boolean <- stream-data-equal? curr-stream, "dup" +538 compare is-dup?, 0 +539 break-if-= +540 # read src-val from out +541 var out2/esi: (addr value-stack) <- copy out +542 var top-addr/ecx: (addr int) <- get out2, top +543 compare *top-addr, 0 +544 break-if-<= +545 var data-ah/eax: (addr handle array value) <- get out2, data +546 var data/eax: (addr array value) <- lookup *data-ah +547 var top/ecx: int <- copy *top-addr +548 top <- decrement +549 var offset/edx: (offset value) <- compute-offset data, top +550 var src-val/edx: (addr value) <- index data, offset +551 # push a copy of it +552 top <- increment +553 var offset/ebx: (offset value) <- compute-offset data, top +554 var target-val/ebx: (addr value) <- index data, offset +555 copy-object src-val, target-val +556 # commit +557 var top-addr/ecx: (addr int) <- get out2, top +558 increment *top-addr +559 break $evaluate:process-word +560 } +561 { +562 var is-swap?/eax: boolean <- stream-data-equal? curr-stream, "swap" +563 compare is-swap?, 0 +564 break-if-= +565 # read top-val from out +566 var out2/esi: (addr value-stack) <- copy out +567 var top-addr/ecx: (addr int) <- get out2, top +568 compare *top-addr, 0 +569 break-if-<= +570 var data-ah/eax: (addr handle array value) <- get out2, data +571 var data/eax: (addr array value) <- lookup *data-ah +572 var top/ecx: int <- copy *top-addr +573 top <- decrement +574 var offset/edx: (offset value) <- compute-offset data, top +575 var top-val/edx: (addr value) <- index data, offset +576 # read next val from out +577 top <- decrement +578 var offset/ebx: (offset value) <- compute-offset data, top +579 var pen-top-val/ebx: (addr value) <- index data, offset +580 # swap +581 var tmp: value +582 var tmp-a/eax: (addr value) <- address tmp +583 copy-object top-val, tmp-a +584 copy-object pen-top-val, top-val +585 copy-object tmp-a, pen-top-val +586 break $evaluate:process-word +587 } +588 ### if curr-stream defines a binding, save top of stack to bindings +589 { +590 var done?/eax: boolean <- stream-empty? curr-stream +591 compare done?, 0 # false +592 break-if-!= +593 var new-byte/eax: byte <- read-byte curr-stream +594 compare new-byte, 0x3d # '=' +595 break-if-!= +596 # pop target-val from out +597 var out2/esi: (addr value-stack) <- copy out +598 var top-addr/ecx: (addr int) <- get out2, top +599 compare *top-addr, 0 +600 break-if-<= +601 var data-ah/eax: (addr handle array value) <- get out2, data +602 var data/eax: (addr array value) <- lookup *data-ah +603 var top/edx: int <- copy *top-addr +604 top <- decrement +605 var dest-offset/edx: (offset value) <- compute-offset data, top +606 var target-val/edx: (addr value) <- index data, dest-offset +607 # create binding from curr-stream to target-val +608 var key-h: (handle array byte) +609 var key/ecx: (addr handle array byte) <- address key-h +610 stream-to-array curr-stream, key +611 bind-in-table bindings, key, target-val +612 break $evaluate:process-word +613 } +614 rewind-stream curr-stream +615 ### if curr-stream is a known function name, call it appropriately +616 { +617 var callee-h: (handle function) +618 var callee-ah/eax: (addr handle function) <- address callee-h +619 find-function functions, curr-stream, callee-ah +620 var callee/eax: (addr function) <- lookup *callee-ah +621 compare callee, 0 +622 break-if-= +623 perform-call callee, out, functions +624 break $evaluate:process-word +625 } +626 ### if it's a name, push its value +627 { +628 compare bindings, 0 +629 break-if-= +630 var tmp: (handle array byte) +631 var curr-string-ah/edx: (addr handle array byte) <- address tmp +632 stream-to-array curr-stream, curr-string-ah # unfortunate leak +633 var curr-string/eax: (addr array byte) <- lookup *curr-string-ah +634 var val-storage: (handle value) +635 var val-ah/edi: (addr handle value) <- address val-storage +636 lookup-binding bindings, curr-string, val-ah +637 var val/eax: (addr value) <- lookup *val-ah +638 compare val, 0 +639 break-if-= +640 push-value-stack out, val +641 break $evaluate:process-word +642 } +643 ### if the word starts with a quote and ends with a quote, turn it into a string +644 { +645 var start/eax: byte <- stream-first curr-stream +646 compare start, 0x22 # double-quote +647 break-if-!= +648 var end/eax: byte <- stream-final curr-stream +649 compare end, 0x22 # double-quote +650 break-if-!= +651 var h: (handle array byte) +652 var s/eax: (addr handle array byte) <- address h +653 unquote-stream-to-array curr-stream, s # leak +654 push-string-to-value-stack out, *s +655 break $evaluate:process-word +656 } +657 ### if the word starts with a '[' and ends with a ']', turn it into an array +658 { +659 var start/eax: byte <- stream-first curr-stream +660 compare start, 0x5b # '[' +661 break-if-!= +662 var end/eax: byte <- stream-final curr-stream +663 compare end, 0x5d # ']' +664 break-if-!= +665 # wastefully create a new input string to strip quotes +666 var h: (handle array value) +667 var input-ah/eax: (addr handle array byte) <- address h +668 unquote-stream-to-array curr-stream, input-ah # leak +669 # wastefully parse input into int-array +670 # TODO: support parsing arrays of other types +671 var input/eax: (addr array byte) <- lookup *input-ah +672 var h2: (handle array int) +673 var int-array-ah/esi: (addr handle array int) <- address h2 +674 parse-array-of-decimal-ints input, int-array-ah # leak +675 var _int-array/eax: (addr array int) <- lookup *int-array-ah +676 var int-array/esi: (addr array int) <- copy _int-array +677 var len/ebx: int <- length int-array +678 # push value-array of same size as int-array +679 var h3: (handle array value) +680 var value-array-ah/eax: (addr handle array value) <- address h3 +681 populate value-array-ah, len +682 push-array-to-value-stack out, *value-array-ah +683 # copy int-array into value-array +684 var _value-array/eax: (addr array value) <- lookup *value-array-ah +685 var value-array/edi: (addr array value) <- copy _value-array +686 var i/eax: int <- copy 0 +687 { +688 compare i, len +689 break-if->= +690 var src-addr/ecx: (addr int) <- index int-array, i +691 var src/ecx: int <- copy *src-addr +692 var dest-offset/edx: (offset value) <- compute-offset value-array, i +693 var dest-val/edx: (addr value) <- index value-array, dest-offset +694 var dest/edx: (addr int) <- get dest-val, int-data +695 copy-to *dest, src +696 i <- increment +697 loop +698 } +699 break $evaluate:process-word +700 } +701 ### otherwise assume it's a literal number and push it +702 { +703 var n/eax: int <- parse-decimal-int-from-stream curr-stream +704 push-int-to-value-stack out, n 705 } -706 ### otherwise assume it's a literal number and push it -707 { -708 var n/eax: int <- parse-decimal-int-from-stream curr-stream -709 push-int-to-value-stack out, n -710 } -711 } -712 # termination check -713 compare curr, end -714 break-if-= -715 # update -716 var next-word-ah/edx: (addr handle word) <- get curr, next -717 curr <- lookup *next-word-ah -718 # -719 loop -720 } -721 # process next line if necessary -722 var line/eax: (addr line) <- copy scratch -723 var next-line-ah/eax: (addr handle line) <- get line, next -724 var next-line/eax: (addr line) <- lookup *next-line-ah -725 compare next-line, 0 -726 break-if-= -727 evaluate functions, bindings, next-line, end, out -728 } -729 -730 fn test-evaluate { -731 var line-storage: line -732 var line/esi: (addr line) <- address line-storage -733 var first-word-ah/eax: (addr handle word) <- get line-storage, data -734 allocate-word-with first-word-ah, "3" -735 append-word-with *first-word-ah, "=a" -736 var next-line-ah/eax: (addr handle line) <- get line-storage, next -737 allocate next-line-ah -738 var next-line/eax: (addr line) <- lookup *next-line-ah -739 var first-word-ah/eax: (addr handle word) <- get next-line, data -740 allocate-word-with first-word-ah, "a" -741 var functions-storage: (handle function) -742 var functions/ecx: (addr handle function) <- address functions-storage -743 var table-storage: table -744 var table/ebx: (addr table) <- address table-storage -745 initialize-table table, 0x10 -746 var stack-storage: value-stack -747 var stack/edi: (addr value-stack) <- address stack-storage -748 initialize-value-stack stack, 0x10 -749 evaluate functions, table, line, 0, stack -750 var x/eax: int <- pop-int-from-value-stack stack -751 check-ints-equal x, 3, "F - test-evaluate" -752 } -753 -754 fn find-function first: (addr handle function), name: (addr stream byte), out: (addr handle function) { -755 var curr/esi: (addr handle function) <- copy first -756 $find-function:loop: { -757 var _f/eax: (addr function) <- lookup *curr -758 var f/ecx: (addr function) <- copy _f -759 compare f, 0 -760 break-if-= -761 var curr-name-ah/eax: (addr handle array byte) <- get f, name -762 var curr-name/eax: (addr array byte) <- lookup *curr-name-ah -763 var done?/eax: boolean <- stream-data-equal? name, curr-name -764 compare done?, 0 # false -765 { -766 break-if-= -767 copy-handle *curr, out -768 break $find-function:loop -769 } -770 curr <- get f, next -771 loop -772 } -773 } -774 -775 fn perform-call _callee: (addr function), caller-stack: (addr value-stack), functions: (addr handle function) { -776 var callee/ecx: (addr function) <- copy _callee -777 # create bindings for args -778 var table-storage: table -779 var table/esi: (addr table) <- address table-storage -780 initialize-table table, 0x10 -781 bind-args callee, caller-stack, table -782 # obtain body -783 var body-ah/eax: (addr handle line) <- get callee, body -784 var body/eax: (addr line) <- lookup *body-ah -785 # perform call -786 var stack-storage: value-stack -787 var stack/edi: (addr value-stack) <- address stack-storage -788 initialize-value-stack stack, 0x10 -789 #? print-string-to-real-screen "about to enter recursive eval\n" -790 evaluate functions, table, body, 0, stack -791 #? print-string-to-real-screen "exited recursive eval\n" -792 # pop target-val from out -793 var top-addr/ecx: (addr int) <- get stack, top -794 compare *top-addr, 0 -795 break-if-<= -796 var data-ah/eax: (addr handle array value) <- get stack, data -797 var data/eax: (addr array value) <- lookup *data-ah -798 var top/edx: int <- copy *top-addr -799 top <- decrement -800 var dest-offset/edx: (offset value) <- compute-offset data, top -801 var target-val/edx: (addr value) <- index data, dest-offset -802 # stitch target-val into caller-stack -803 push-value-stack caller-stack, target-val -804 } -805 -806 # pop args from the caller-stack and bind them to successive args -807 # implies: function args are stored in reverse order -808 fn bind-args _callee: (addr function), _caller-stack: (addr value-stack), table: (addr table) { -809 var callee/ecx: (addr function) <- copy _callee -810 var curr-arg-ah/eax: (addr handle word) <- get callee, args -811 var curr-arg/eax: (addr word) <- lookup *curr-arg-ah -812 # -813 var curr-key-storage: (handle array byte) -814 var curr-key/edx: (addr handle array byte) <- address curr-key-storage -815 { -816 compare curr-arg, 0 -817 break-if-= -818 # create binding -819 word-to-string curr-arg, curr-key -820 { -821 # pop target-val from caller-stack -822 var caller-stack/esi: (addr value-stack) <- copy _caller-stack -823 var top-addr/ecx: (addr int) <- get caller-stack, top -824 compare *top-addr, 0 -825 break-if-<= -826 decrement *top-addr -827 var data-ah/eax: (addr handle array value) <- get caller-stack, data -828 var data/eax: (addr array value) <- lookup *data-ah -829 var top/ebx: int <- copy *top-addr -830 var dest-offset/ebx: (offset value) <- compute-offset data, top -831 var target-val/ebx: (addr value) <- index data, dest-offset -832 # create binding from curr-key to target-val -833 bind-in-table table, curr-key, target-val -834 } -835 # -836 var next-arg-ah/edx: (addr handle word) <- get curr-arg, next -837 curr-arg <- lookup *next-arg-ah -838 loop -839 } -840 } -841 -842 # Copy of 'simplify' that just tracks the maximum stack depth needed -843 # Doesn't actually need to simulate the stack, since every word has a predictable effect. -844 fn max-stack-depth first-word: (addr word), final-word: (addr word) -> _/edi: int { -845 var curr-word/eax: (addr word) <- copy first-word -846 var curr-depth/ecx: int <- copy 0 -847 var result/edi: int <- copy 0 -848 $max-stack-depth:loop: { -849 $max-stack-depth:process-word: { -850 # handle operators -851 { -852 var is-add?/eax: boolean <- word-equal? curr-word, "+" -853 compare is-add?, 0 -854 break-if-= -855 curr-depth <- decrement -856 break $max-stack-depth:process-word -857 } -858 { -859 var is-sub?/eax: boolean <- word-equal? curr-word, "-" -860 compare is-sub?, 0 -861 break-if-= -862 curr-depth <- decrement -863 break $max-stack-depth:process-word -864 } -865 { -866 var is-mul?/eax: boolean <- word-equal? curr-word, "*" -867 compare is-mul?, 0 -868 break-if-= -869 curr-depth <- decrement -870 break $max-stack-depth:process-word -871 } -872 # otherwise it's an int (do we need error-checking?) -873 curr-depth <- increment -874 # update max depth if necessary -875 { -876 compare curr-depth, result -877 break-if-<= -878 result <- copy curr-depth -879 } -880 } -881 # if curr-word == final-word break -882 compare curr-word, final-word -883 break-if-= -884 # curr-word = curr-word->next -885 var next-word-ah/edx: (addr handle word) <- get curr-word, next -886 curr-word <- lookup *next-word-ah -887 # -888 loop -889 } -890 return result -891 } +706 } +707 # termination check +708 compare curr, end +709 break-if-= +710 # update +711 var next-word-ah/edx: (addr handle word) <- get curr, next +712 curr <- lookup *next-word-ah +713 # +714 loop +715 } +716 # process next line if necessary +717 var line/eax: (addr line) <- copy scratch +718 var next-line-ah/eax: (addr handle line) <- get line, next +719 var next-line/eax: (addr line) <- lookup *next-line-ah +720 compare next-line, 0 +721 break-if-= +722 evaluate functions, bindings, next-line, end, out +723 } +724 +725 fn test-evaluate { +726 var line-storage: line +727 var line/esi: (addr line) <- address line-storage +728 var first-word-ah/eax: (addr handle word) <- get line-storage, data +729 allocate-word-with first-word-ah, "3" +730 append-word-with *first-word-ah, "=a" +731 var next-line-ah/eax: (addr handle line) <- get line-storage, next +732 allocate next-line-ah +733 var next-line/eax: (addr line) <- lookup *next-line-ah +734 var first-word-ah/eax: (addr handle word) <- get next-line, data +735 allocate-word-with first-word-ah, "a" +736 var functions-storage: (handle function) +737 var functions/ecx: (addr handle function) <- address functions-storage +738 var table-storage: table +739 var table/ebx: (addr table) <- address table-storage +740 initialize-table table, 0x10 +741 var stack-storage: value-stack +742 var stack/edi: (addr value-stack) <- address stack-storage +743 initialize-value-stack stack, 0x10 +744 evaluate functions, table, line, 0, stack +745 var x/eax: int <- pop-int-from-value-stack stack +746 check-ints-equal x, 3, "F - test-evaluate" +747 } +748 +749 fn find-function first: (addr handle function), name: (addr stream byte), out: (addr handle function) { +750 var curr/esi: (addr handle function) <- copy first +751 $find-function:loop: { +752 var _f/eax: (addr function) <- lookup *curr +753 var f/ecx: (addr function) <- copy _f +754 compare f, 0 +755 break-if-= +756 var curr-name-ah/eax: (addr handle array byte) <- get f, name +757 var curr-name/eax: (addr array byte) <- lookup *curr-name-ah +758 var done?/eax: boolean <- stream-data-equal? name, curr-name +759 compare done?, 0 # false +760 { +761 break-if-= +762 copy-handle *curr, out +763 break $find-function:loop +764 } +765 curr <- get f, next +766 loop +767 } +768 } +769 +770 fn perform-call _callee: (addr function), caller-stack: (addr value-stack), functions: (addr handle function) { +771 var callee/ecx: (addr function) <- copy _callee +772 # create bindings for args +773 var table-storage: table +774 var table/esi: (addr table) <- address table-storage +775 initialize-table table, 0x10 +776 bind-args callee, caller-stack, table +777 # obtain body +778 var body-ah/eax: (addr handle line) <- get callee, body +779 var body/eax: (addr line) <- lookup *body-ah +780 # perform call +781 var stack-storage: value-stack +782 var stack/edi: (addr value-stack) <- address stack-storage +783 initialize-value-stack stack, 0x10 +784 #? print-string-to-real-screen "about to enter recursive eval\n" +785 evaluate functions, table, body, 0, stack +786 #? print-string-to-real-screen "exited recursive eval\n" +787 # pop target-val from out +788 var top-addr/ecx: (addr int) <- get stack, top +789 compare *top-addr, 0 +790 break-if-<= +791 var data-ah/eax: (addr handle array value) <- get stack, data +792 var data/eax: (addr array value) <- lookup *data-ah +793 var top/edx: int <- copy *top-addr +794 top <- decrement +795 var dest-offset/edx: (offset value) <- compute-offset data, top +796 var target-val/edx: (addr value) <- index data, dest-offset +797 # stitch target-val into caller-stack +798 push-value-stack caller-stack, target-val +799 } +800 +801 # pop args from the caller-stack and bind them to successive args +802 # implies: function args are stored in reverse order +803 fn bind-args _callee: (addr function), _caller-stack: (addr value-stack), table: (addr table) { +804 var callee/ecx: (addr function) <- copy _callee +805 var curr-arg-ah/eax: (addr handle word) <- get callee, args +806 var curr-arg/eax: (addr word) <- lookup *curr-arg-ah +807 # +808 var curr-key-storage: (handle array byte) +809 var curr-key/edx: (addr handle array byte) <- address curr-key-storage +810 { +811 compare curr-arg, 0 +812 break-if-= +813 # create binding +814 word-to-string curr-arg, curr-key +815 { +816 # pop target-val from caller-stack +817 var caller-stack/esi: (addr value-stack) <- copy _caller-stack +818 var top-addr/ecx: (addr int) <- get caller-stack, top +819 compare *top-addr, 0 +820 break-if-<= +821 decrement *top-addr +822 var data-ah/eax: (addr handle array value) <- get caller-stack, data +823 var data/eax: (addr array value) <- lookup *data-ah +824 var top/ebx: int <- copy *top-addr +825 var dest-offset/ebx: (offset value) <- compute-offset data, top +826 var target-val/ebx: (addr value) <- index data, dest-offset +827 # create binding from curr-key to target-val +828 bind-in-table table, curr-key, target-val +829 } +830 # +831 var next-arg-ah/edx: (addr handle word) <- get curr-arg, next +832 curr-arg <- lookup *next-arg-ah +833 loop +834 } +835 } +836 +837 # Copy of 'simplify' that just tracks the maximum stack depth needed +838 # Doesn't actually need to simulate the stack, since every word has a predictable effect. +839 fn max-stack-depth first-word: (addr word), final-word: (addr word) -> _/edi: int { +840 var curr-word/eax: (addr word) <- copy first-word +841 var curr-depth/ecx: int <- copy 0 +842 var result/edi: int <- copy 0 +843 $max-stack-depth:loop: { +844 $max-stack-depth:process-word: { +845 # handle operators +846 { +847 var is-add?/eax: boolean <- word-equal? curr-word, "+" +848 compare is-add?, 0 +849 break-if-= +850 curr-depth <- decrement +851 break $max-stack-depth:process-word +852 } +853 { +854 var is-sub?/eax: boolean <- word-equal? curr-word, "-" +855 compare is-sub?, 0 +856 break-if-= +857 curr-depth <- decrement +858 break $max-stack-depth:process-word +859 } +860 { +861 var is-mul?/eax: boolean <- word-equal? curr-word, "*" +862 compare is-mul?, 0 +863 break-if-= +864 curr-depth <- decrement +865 break $max-stack-depth:process-word +866 } +867 # otherwise it's an int (do we need error-checking?) +868 curr-depth <- increment +869 # update max depth if necessary +870 { +871 compare curr-depth, result +872 break-if-<= +873 result <- copy curr-depth +874 } +875 } +876 # if curr-word == final-word break +877 compare curr-word, final-word +878 break-if-= +879 # curr-word = curr-word->next +880 var next-word-ah/edx: (addr handle word) <- get curr-word, next +881 curr-word <- lookup *next-word-ah +882 # +883 loop +884 } +885 return result +886 } diff --git a/html/apps/tile/value.mu.html b/html/apps/tile/value.mu.html index 6da9cb3d..e982b2bd 100644 --- a/html/apps/tile/value.mu.html +++ b/html/apps/tile/value.mu.html @@ -130,7 +130,7 @@ if ('onhashchange' in window) { 71 print-int32-decimal screen, val 72 break $render-integer:body 73 } - 74 var bg/eax: int <- hash-color val + 74 var bg/eax: int <- hash-color val 75 var fg/ecx: int <- copy 7 76 { 77 compare bg, 2 @@ -174,7 +174,7 @@ if ('onhashchange' in window) { 115 var x/ecx: (addr value) <- index a, off 116 render-value-at screen, row, col, x, 0 117 { -118 var w/eax: int <- value-width x, 0 +118 var w/eax: int <- value-width x, 0 119 add-to col, w 120 increment col 121 } @@ -186,301 +186,299 @@ if ('onhashchange' in window) { 127 128 fn render-screen screen: (addr screen), row: int, col: int, _target-screen: (addr screen) { 129 reset-formatting screen -130 start-color screen, 0xf2, 7 -131 move-cursor screen, row, col -132 var target-screen/esi: (addr screen) <- copy _target-screen -133 var ncols-a/ecx: (addr int) <- get target-screen, num-cols -134 print-upper-border screen, *ncols-a -135 var r/edx: int <- copy 1 -136 var nrows-a/ebx: (addr int) <- get target-screen, num-rows -137 { -138 compare r, *nrows-a -139 break-if-> -140 increment row # mutate arg -141 move-cursor screen, row, col -142 print-string screen, " " -143 var c/edi: int <- copy 1 -144 { -145 compare c, *ncols-a -146 break-if-> -147 print-screen-cell-of-fake-screen screen, target-screen, r, c -148 c <- increment -149 loop -150 } -151 print-string screen, " " -152 r <- increment -153 loop -154 } -155 increment row # mutate arg -156 move-cursor screen, row, col -157 start-color screen, 0xf2, 7 -158 print-lower-border screen, *ncols-a -159 } -160 -161 fn hash-color val: int -> _/eax: int { -162 var result/eax: int <- try-modulo val, 7 # assumes that 7 is always the background color -163 return result -164 } -165 -166 fn print-screen-cell-of-fake-screen screen: (addr screen), _target: (addr screen), _row: int, _col: int { -167 start-color screen, 0, 0xf6 -168 var target/esi: (addr screen) <- copy _target -169 var row/ecx: int <- copy _row -170 var col/edx: int <- copy _col -171 # if cursor is at screen-cell, add some fancy -172 { -173 var cursor-row/eax: (addr int) <- get target, cursor-row -174 compare *cursor-row, row -175 break-if-!= -176 var cursor-col/eax: (addr int) <- get target, cursor-col -177 compare *cursor-col, col -178 break-if-!= -179 start-blinking screen -180 start-color screen, 0, 1 -181 } -182 var g/eax: grapheme <- screen-grapheme-at target, row, col -183 { -184 compare g, 0 -185 break-if-!= -186 g <- copy 0x20 # space -187 } -188 print-grapheme screen, g -189 reset-formatting screen -190 } -191 -192 fn print-upper-border screen: (addr screen), width: int { -193 print-code-point screen, 0x250c # top-left corner -194 var i/eax: int <- copy 0 -195 { -196 compare i, width -197 break-if->= -198 print-code-point screen, 0x2500 # horizontal line -199 i <- increment -200 loop -201 } -202 print-code-point screen, 0x2510 # top-right corner -203 } -204 -205 fn print-lower-border screen: (addr screen), width: int { -206 print-code-point screen, 0x2514 # bottom-left corner -207 var i/eax: int <- copy 0 -208 { -209 compare i, width -210 break-if->= -211 print-code-point screen, 0x2500 # horizontal line -212 i <- increment -213 loop -214 } -215 print-code-point screen, 0x2518 # bottom-right corner -216 } -217 -218 fn value-width _v: (addr value), top-level: boolean -> _/eax: int { -219 var v/esi: (addr value) <- copy _v -220 var type/eax: (addr int) <- get v, type -221 { -222 compare *type, 0 # int -223 break-if-!= -224 var v-int/edx: (addr int) <- get v, int-data -225 var result/eax: int <- decimal-size *v-int -226 return result -227 } -228 { -229 compare *type, 1 # string -230 break-if-!= -231 var s-ah/eax: (addr handle array byte) <- get v, text-data -232 var s/eax: (addr array byte) <- lookup *s-ah -233 compare s, 0 -234 break-if-= -235 var result/eax: int <- length s -236 compare result, 0xd # max string size -237 { -238 break-if-<= -239 result <- copy 0xd -240 } -241 # if it's a nested string, include space for quotes -242 # we don't do this for the top-level, where the quotes will overflow -243 # into surrounding padding. -244 compare top-level, 0 # false -245 { -246 break-if-!= -247 result <- add 2 -248 } -249 return result -250 } -251 { -252 compare *type, 2 # array -253 break-if-!= -254 var a-ah/eax: (addr handle array value) <- get v, array-data -255 var a/eax: (addr array value) <- lookup *a-ah -256 compare a, 0 -257 break-if-= -258 var result/eax: int <- array-width a -259 return result -260 } -261 { -262 compare *type, 3 # file handle -263 break-if-!= -264 var f-ah/eax: (addr handle buffered-file) <- get v, file-data -265 var f/eax: (addr buffered-file) <- lookup *f-ah -266 compare f, 0 -267 break-if-= -268 # TODO: visualizing file handles -269 return 4 -270 } -271 { -272 compare *type, 4 # screen -273 break-if-!= -274 var screen-ah/eax: (addr handle screen) <- get v, screen-data -275 var screen/eax: (addr screen) <- lookup *screen-ah -276 compare screen, 0 -277 break-if-= -278 var ncols/ecx: (addr int) <- get screen, num-cols -279 var result/eax: int <- copy *ncols -280 result <- add 2 # left/right margins -281 return *ncols -282 } -283 return 0 -284 } -285 -286 # keep sync'd with render-array-at -287 fn array-width _a: (addr array value) -> _/eax: int { -288 var a/esi: (addr array value) <- copy _a -289 var max/ecx: int <- length a -290 var i/eax: int <- copy 0 -291 var result/edi: int <- copy 0 -292 { -293 compare i, max -294 break-if->= -295 { -296 compare i, 0 -297 break-if-= -298 result <- increment # for space -299 } -300 var off/ecx: (offset value) <- compute-offset a, i -301 var x/ecx: (addr value) <- index a, off -302 { -303 var w/eax: int <- value-width x, 0 -304 result <- add w -305 } -306 i <- increment -307 loop -308 } -309 # we won't add 2 for surrounding brackets since we don't surround arrays in -310 # spaces like other value types -311 return result -312 } -313 -314 fn value-height _v: (addr value) -> _/eax: int { -315 var v/esi: (addr value) <- copy _v -316 var type/eax: (addr int) <- get v, type -317 { -318 compare *type, 3 # file handle -319 break-if-!= -320 # TODO: visualizing file handles -321 return 1 -322 } -323 { -324 compare *type, 4 # screen -325 break-if-!= -326 var screen-ah/eax: (addr handle screen) <- get v, screen-data -327 var screen/eax: (addr screen) <- lookup *screen-ah -328 compare screen, 0 -329 break-if-= -330 var nrows/ecx: (addr int) <- get screen, num-rows -331 var result/eax: int <- copy *nrows -332 result <- add 2 # top and bottom border -333 return result -334 } -335 return 1 -336 } -337 -338 fn deep-copy-value _src: (addr value), _dest: (addr value) { -339 #? print-string 0, "deep-copy-value\n" -340 var src/esi: (addr value) <- copy _src -341 var dest/edi: (addr value) <- copy _dest -342 var type/ebx: (addr int) <- get src, type -343 var y/ecx: (addr int) <- get dest, type -344 copy-object type, y -345 compare *type, 0 # int -346 { -347 break-if-!= -348 #? print-string 0, "int value\n" -349 var x/eax: (addr int) <- get src, int-data -350 y <- get dest, int-data -351 copy-object x, y -352 return -353 } -354 compare *type, 1 # string -355 { -356 break-if-!= -357 #? print-string 0, "string value\n" -358 var src-ah/eax: (addr handle array byte) <- get src, text-data -359 var src/eax: (addr array byte) <- lookup *src-ah -360 var dest-ah/edx: (addr handle array byte) <- get dest, text-data -361 copy-array-object src, dest-ah -362 return -363 } -364 compare *type, 2 # array -365 { -366 break-if-!= -367 #? print-string 0, "array value\n" -368 var src-ah/eax: (addr handle array value) <- get src, array-data -369 var _src/eax: (addr array value) <- lookup *src-ah -370 var src/esi: (addr array value) <- copy _src -371 var n/ecx: int <- length src -372 var dest-ah/edx: (addr handle array value) <- get dest, array-data -373 populate dest-ah, n -374 var _dest/eax: (addr array value) <- lookup *dest-ah -375 var dest/edi: (addr array value) <- copy _dest -376 var i/eax: int <- copy 0 -377 { -378 compare i, n -379 break-if->= -380 { -381 var offset/edx: (offset value) <- compute-offset src, i -382 var src-element/eax: (addr value) <- index src, offset -383 var dest-element/ecx: (addr value) <- index dest, offset -384 deep-copy-value src-element, dest-element -385 } -386 i <- increment -387 loop -388 } -389 copy-array-object src, dest-ah -390 return -391 } -392 compare *type, 3 # file -393 { -394 break-if-!= -395 #? print-string 0, "file value\n" -396 var src-filename-ah/eax: (addr handle array byte) <- get src, filename -397 var _src-filename/eax: (addr array byte) <- lookup *src-filename-ah -398 var src-filename/ecx: (addr array byte) <- copy _src-filename -399 var dest-filename-ah/ebx: (addr handle array byte) <- get dest, filename -400 copy-array-object src-filename, dest-filename-ah -401 var src-file-ah/eax: (addr handle buffered-file) <- get src, file-data -402 var src-file/eax: (addr buffered-file) <- lookup *src-file-ah -403 var dest-file-ah/edx: (addr handle buffered-file) <- get dest, file-data -404 copy-file src-file, dest-file-ah, src-filename -405 return -406 } -407 compare *type, 4 # screen -408 { -409 break-if-!= -410 #? print-string 0, "screen value\n" -411 var src-screen-ah/eax: (addr handle screen) <- get src, screen-data -412 var _src-screen/eax: (addr screen) <- lookup *src-screen-ah -413 var src-screen/ecx: (addr screen) <- copy _src-screen -414 var dest-screen-ah/eax: (addr handle screen) <- get dest, screen-data -415 allocate dest-screen-ah -416 var dest-screen/eax: (addr screen) <- lookup *dest-screen-ah -417 copy-object src-screen, dest-screen -418 var dest-screen-data-ah/ebx: (addr handle array screen-cell) <- get dest-screen, data -419 var src-screen-data-ah/eax: (addr handle array screen-cell) <- get src-screen, data -420 var src-screen-data/eax: (addr array screen-cell) <- lookup *src-screen-data-ah -421 copy-array-object src-screen-data, dest-screen-data-ah -422 return -423 } -424 } +130 move-cursor screen, row, col +131 var target-screen/esi: (addr screen) <- copy _target-screen +132 var ncols-a/ecx: (addr int) <- get target-screen, num-cols +133 print-upper-border screen, *ncols-a +134 var r/edx: int <- copy 1 +135 var nrows-a/ebx: (addr int) <- get target-screen, num-rows +136 { +137 compare r, *nrows-a +138 break-if-> +139 increment row # mutate arg +140 move-cursor screen, row, col +141 print-string screen, " " +142 var c/edi: int <- copy 1 +143 { +144 compare c, *ncols-a +145 break-if-> +146 print-screen-cell-of-fake-screen screen, target-screen, r, c +147 c <- increment +148 loop +149 } +150 print-string screen, " " +151 r <- increment +152 loop +153 } +154 increment row # mutate arg +155 move-cursor screen, row, col +156 print-lower-border screen, *ncols-a +157 } +158 +159 fn hash-color val: int -> _/eax: int { +160 var result/eax: int <- try-modulo val, 7 # assumes that 7 is always the background color +161 return result +162 } +163 +164 fn print-screen-cell-of-fake-screen screen: (addr screen), _target: (addr screen), _row: int, _col: int { +165 start-color screen, 0, 0xf6 +166 var target/esi: (addr screen) <- copy _target +167 var row/ecx: int <- copy _row +168 var col/edx: int <- copy _col +169 # if cursor is at screen-cell, add some fancy +170 { +171 var cursor-row/eax: (addr int) <- get target, cursor-row +172 compare *cursor-row, row +173 break-if-!= +174 var cursor-col/eax: (addr int) <- get target, cursor-col +175 compare *cursor-col, col +176 break-if-!= +177 start-blinking screen +178 start-color screen, 0, 1 +179 } +180 var g/eax: grapheme <- screen-grapheme-at target, row, col +181 { +182 compare g, 0 +183 break-if-!= +184 g <- copy 0x20 # space +185 } +186 print-grapheme screen, g +187 reset-formatting screen +188 } +189 +190 fn print-upper-border screen: (addr screen), width: int { +191 print-code-point screen, 0x250c # top-left corner +192 var i/eax: int <- copy 0 +193 { +194 compare i, width +195 break-if->= +196 print-code-point screen, 0x2500 # horizontal line +197 i <- increment +198 loop +199 } +200 print-code-point screen, 0x2510 # top-right corner +201 } +202 +203 fn print-lower-border screen: (addr screen), width: int { +204 print-code-point screen, 0x2514 # bottom-left corner +205 var i/eax: int <- copy 0 +206 { +207 compare i, width +208 break-if->= +209 print-code-point screen, 0x2500 # horizontal line +210 i <- increment +211 loop +212 } +213 print-code-point screen, 0x2518 # bottom-right corner +214 } +215 +216 fn value-width _v: (addr value), top-level: boolean -> _/eax: int { +217 var v/esi: (addr value) <- copy _v +218 var type/eax: (addr int) <- get v, type +219 { +220 compare *type, 0 # int +221 break-if-!= +222 var v-int/edx: (addr int) <- get v, int-data +223 var result/eax: int <- decimal-size *v-int +224 return result +225 } +226 { +227 compare *type, 1 # string +228 break-if-!= +229 var s-ah/eax: (addr handle array byte) <- get v, text-data +230 var s/eax: (addr array byte) <- lookup *s-ah +231 compare s, 0 +232 break-if-= +233 var result/eax: int <- length s +234 compare result, 0xd # max string size +235 { +236 break-if-<= +237 result <- copy 0xd +238 } +239 # if it's a nested string, include space for quotes +240 # we don't do this for the top-level, where the quotes will overflow +241 # into surrounding padding. +242 compare top-level, 0 # false +243 { +244 break-if-!= +245 result <- add 2 +246 } +247 return result +248 } +249 { +250 compare *type, 2 # array +251 break-if-!= +252 var a-ah/eax: (addr handle array value) <- get v, array-data +253 var a/eax: (addr array value) <- lookup *a-ah +254 compare a, 0 +255 break-if-= +256 var result/eax: int <- array-width a +257 return result +258 } +259 { +260 compare *type, 3 # file handle +261 break-if-!= +262 var f-ah/eax: (addr handle buffered-file) <- get v, file-data +263 var f/eax: (addr buffered-file) <- lookup *f-ah +264 compare f, 0 +265 break-if-= +266 # TODO: visualizing file handles +267 return 4 +268 } +269 { +270 compare *type, 4 # screen +271 break-if-!= +272 var screen-ah/eax: (addr handle screen) <- get v, screen-data +273 var screen/eax: (addr screen) <- lookup *screen-ah +274 compare screen, 0 +275 break-if-= +276 var ncols/ecx: (addr int) <- get screen, num-cols +277 var result/eax: int <- copy *ncols +278 result <- add 2 # left/right margins +279 return *ncols +280 } +281 return 0 +282 } +283 +284 # keep sync'd with render-array-at +285 fn array-width _a: (addr array value) -> _/eax: int { +286 var a/esi: (addr array value) <- copy _a +287 var max/ecx: int <- length a +288 var i/eax: int <- copy 0 +289 var result/edi: int <- copy 0 +290 { +291 compare i, max +292 break-if->= +293 { +294 compare i, 0 +295 break-if-= +296 result <- increment # for space +297 } +298 var off/ecx: (offset value) <- compute-offset a, i +299 var x/ecx: (addr value) <- index a, off +300 { +301 var w/eax: int <- value-width x, 0 +302 result <- add w +303 } +304 i <- increment +305 loop +306 } +307 # we won't add 2 for surrounding brackets since we don't surround arrays in +308 # spaces like other value types +309 return result +310 } +311 +312 fn value-height _v: (addr value) -> _/eax: int { +313 var v/esi: (addr value) <- copy _v +314 var type/eax: (addr int) <- get v, type +315 { +316 compare *type, 3 # file handle +317 break-if-!= +318 # TODO: visualizing file handles +319 return 1 +320 } +321 { +322 compare *type, 4 # screen +323 break-if-!= +324 var screen-ah/eax: (addr handle screen) <- get v, screen-data +325 var screen/eax: (addr screen) <- lookup *screen-ah +326 compare screen, 0 +327 break-if-= +328 var nrows/ecx: (addr int) <- get screen, num-rows +329 var result/eax: int <- copy *nrows +330 result <- add 2 # top and bottom border +331 return result +332 } +333 return 1 +334 } +335 +336 fn deep-copy-value _src: (addr value), _dest: (addr value) { +337 #? print-string 0, "deep-copy-value\n" +338 var src/esi: (addr value) <- copy _src +339 var dest/edi: (addr value) <- copy _dest +340 var type/ebx: (addr int) <- get src, type +341 var y/ecx: (addr int) <- get dest, type +342 copy-object type, y +343 compare *type, 0 # int +344 { +345 break-if-!= +346 #? print-string 0, "int value\n" +347 var x/eax: (addr int) <- get src, int-data +348 y <- get dest, int-data +349 copy-object x, y +350 return +351 } +352 compare *type, 1 # string +353 { +354 break-if-!= +355 #? print-string 0, "string value\n" +356 var src-ah/eax: (addr handle array byte) <- get src, text-data +357 var src/eax: (addr array byte) <- lookup *src-ah +358 var dest-ah/edx: (addr handle array byte) <- get dest, text-data +359 copy-array-object src, dest-ah +360 return +361 } +362 compare *type, 2 # array +363 { +364 break-if-!= +365 #? print-string 0, "array value\n" +366 var src-ah/eax: (addr handle array value) <- get src, array-data +367 var _src/eax: (addr array value) <- lookup *src-ah +368 var src/esi: (addr array value) <- copy _src +369 var n/ecx: int <- length src +370 var dest-ah/edx: (addr handle array value) <- get dest, array-data +371 populate dest-ah, n +372 var _dest/eax: (addr array value) <- lookup *dest-ah +373 var dest/edi: (addr array value) <- copy _dest +374 var i/eax: int <- copy 0 +375 { +376 compare i, n +377 break-if->= +378 { +379 var offset/edx: (offset value) <- compute-offset src, i +380 var src-element/eax: (addr value) <- index src, offset +381 var dest-element/ecx: (addr value) <- index dest, offset +382 deep-copy-value src-element, dest-element +383 } +384 i <- increment +385 loop +386 } +387 copy-array-object src, dest-ah +388 return +389 } +390 compare *type, 3 # file +391 { +392 break-if-!= +393 #? print-string 0, "file value\n" +394 var src-filename-ah/eax: (addr handle array byte) <- get src, filename +395 var _src-filename/eax: (addr array byte) <- lookup *src-filename-ah +396 var src-filename/ecx: (addr array byte) <- copy _src-filename +397 var dest-filename-ah/ebx: (addr handle array byte) <- get dest, filename +398 copy-array-object src-filename, dest-filename-ah +399 var src-file-ah/eax: (addr handle buffered-file) <- get src, file-data +400 var src-file/eax: (addr buffered-file) <- lookup *src-file-ah +401 var dest-file-ah/edx: (addr handle buffered-file) <- get dest, file-data +402 copy-file src-file, dest-file-ah, src-filename +403 return +404 } +405 compare *type, 4 # screen +406 { +407 break-if-!= +408 #? print-string 0, "screen value\n" +409 var src-screen-ah/eax: (addr handle screen) <- get src, screen-data +410 var _src-screen/eax: (addr screen) <- lookup *src-screen-ah +411 var src-screen/ecx: (addr screen) <- copy _src-screen +412 var dest-screen-ah/eax: (addr handle screen) <- get dest, screen-data +413 allocate dest-screen-ah +414 var dest-screen/eax: (addr screen) <- lookup *dest-screen-ah +415 copy-object src-screen, dest-screen +416 var dest-screen-data-ah/ebx: (addr handle array screen-cell) <- get dest-screen, data +417 var src-screen-data-ah/eax: (addr handle array screen-cell) <- get src-screen, data +418 var src-screen-data/eax: (addr array screen-cell) <- lookup *src-screen-data-ah +419 copy-array-object src-screen-data, dest-screen-data-ah +420 return +421 } +422 } diff --git a/html/apps/tile/word.mu.html b/html/apps/tile/word.mu.html index 3c66be45..89adc88b 100644 --- a/html/apps/tile/word.mu.html +++ b/html/apps/tile/word.mu.html @@ -337,7 +337,7 @@ if ('onhashchange' in window) { 278 break-if-= 279 # recurse 280 var next-ah/ecx: (addr handle word) <- get words-a, next -281 print-words screen, next-ah +281 print-words-in-reverse screen, next-ah 282 # print 283 print-word screen, words-a 284 print-string screen, " " @@ -612,6 +612,24 @@ if ('onhashchange' in window) { 553 var result/ebx: boolean <- word-exists? next-haystack-ah, _needle 554 return result 555 } +556 +557 fn word-list-length words: (addr handle word) -> _/eax: int { +558 var curr-ah/esi: (addr handle word) <- copy words +559 var result/edi: int <- copy 0 +560 { +561 var curr/eax: (addr word) <- lookup *curr-ah +562 compare curr, 0 +563 break-if-= +564 { +565 var word-len/eax: int <- word-length curr +566 result <- add word-len +567 result <- add 1 # inter-word-margin +568 } +569 curr-ah <- get curr, next +570 loop +571 } +572 return result +573 } diff --git a/html/mu_instructions.html b/html/mu_instructions.html index 2403bdff..2bbee1bf 100644 --- a/html/mu_instructions.html +++ b/html/mu_instructions.html @@ -341,11 +341,11 @@ var/reg: (addr T) <- address var2: T var/reg <- index arr/rega: (addr array T), idx/regi: int | if size-of(T) is 4 or 8 => "8d/copy-address *(" rega "+" regi "<<" log2(size-of(T)) "+4) " reg "/r32" -var/reg <- index arr: (array T sz), idx/regi: int +var/reg <- index arr: (array T len), idx/regi: int => "8d/copy-address *(ebp+" regi "<<" log2(size-of(T)) "+" (arr.stack-offset + 4) ") " reg "/r32" var/reg <- index arr/rega: (addr array T), n => "8d/copy-address *(" rega "+" (n*size-of(T)+4) ") " reg "/r32" -var/reg <- index arr: (array T sz), n +var/reg <- index arr: (array T len), n => "8d/copy-address *(ebp+" (arr.stack-offset+4+n*size-of(T)) ") " reg "/r32" var/reg: (offset T) <- compute-offset arr: (addr array T), idx/regi: int # arr can be in reg or mem @@ -406,6 +406,11 @@ populate in: (addr handle array T), num # can be litera populate-stream in: (addr handle stream T), num # can be literal or variable on stack or register => "(new-stream Heap " size-of(T) " " num " " in ")" +# Some miscellaneous helpers to avoid error-prone size computations + +clear x: (addr T) + => "(zero-out " s " " size-of(T) ")" + read-from-stream s: (addr stream T), out: (addr T) => "(read-from-stream " s " " out " " size-of(T) ")"