diff --git a/018jump_disp32.cc b/018jump_disp32.cc index 13b62b06..1ac4f9ec 100644 --- a/018jump_disp32.cc +++ b/018jump_disp32.cc @@ -293,7 +293,7 @@ case 0x8c: { // jump disp32 if SF and !ZF } break; } -case 0x72: { // jump disp32 if CF +case 0x82: { // jump disp32 if CF const int32_t offset = next32(); if (CF) { trace(Callstack_depth+1, "run") << "jump " << offset << end(); diff --git a/apps/mu b/apps/mu index 0e2717c7..6dcfa90b 100755 Binary files a/apps/mu and b/apps/mu differ diff --git a/apps/mu.subx b/apps/mu.subx index f01b50cf..da3dc578 100644 --- a/apps/mu.subx +++ b/apps/mu.subx @@ -711,11 +711,9 @@ $parse-mu:fn: # var new-function/eax : (handle function) = populate-mu-function(in, new-function, vars) (allocate Heap *Function-size) # => eax (zero-out %eax *Function-size) + (clear-stack %ebx) (populate-mu-function-header %ecx %eax %ebx) (populate-mu-function-body *(ebp+8) %eax %ebx) - # assert(vars->top == 0) - 81 7/subop/compare *ebx 0/imm32 - 75/jump-if-not-equal $parse-mu:error2/disp8 # *curr-function = new-function 89/<- *edi 0/r32/eax # curr-function = &new-function->next @@ -775,7 +773,7 @@ $parse-mu:error2: # ✓ fn foo x : int { # ✓ fn foo x: int { # ✓ fn foo x: int -> y/eax: int { -populate-mu-function-header: # first-line : (address stream byte), out : (handle function), vars : (address stack (address var)) +populate-mu-function-header: # first-line : (address stream byte), out : (handle function), vars : (address stack (handle var)) # pseudocode: # var name : (ref slice) # next-word(first-line, name) @@ -792,9 +790,9 @@ populate-mu-function-header: # first-line : (address stream byte), out : (handl # var v : (handle var) = parse-var-with-type(name, first-line) # assert(v->register == null) # v->stack-offset = next-offset - # next-offset += size-of(var) - # push(vars, var) + # next-offset += size-of(v) # out->inouts = append(out->inouts, v) + # push(vars, v) # ## outputs # while true # ## name @@ -851,25 +849,26 @@ $populate-mu-function-header:check-for-inout: # if (word-slice == '->') break (slice-equal? %ecx "->") # => eax 3d/compare-eax-and 0/imm32 - 75/jump-if-not-equal break/disp8 + 0f 85/jump-if-not-equal break/disp32 # if (word-slice == '}') abort (slice-equal? %ecx "}") # => eax 3d/compare-eax-and 0/imm32 0f 85/jump-if-not-equal $populate-mu-function-header:error1/disp32 - # var var/ebx : (handle var) = parse-var-with-type(word-slice, first-line) + # var v/ebx : (handle var) = parse-var-with-type(word-slice, first-line) (parse-var-with-type %ecx *(ebp+8)) # => eax 89/<- %ebx 0/r32/eax - # assert(var->register == null) + # assert(v->register == null) 81 7/subop/compare *(ebx+0x10) 0/imm32 # Var-register 0f 85/jump-if-not-equal $populate-mu-function-header:error2/disp32 - # var->stack-offset = next-offset + # v->stack-offset = next-offset 89/<- *(ebx+0xc) 2/r32/edx # Var-stack-offset - # next-offset += size-of(var) + # next-offset += size-of(v) (size-of %ebx) # => eax 01/add %edx 0/r32/eax # (append-list Heap %ebx *(edi+8)) # Function-inouts => eax 89/<- *(edi+8) 0/r32/eax # Function-inouts + (push *(ebp+0x10) %ebx) # e9/jump loop/disp32 } @@ -969,8 +968,13 @@ test-function-header-with-arg: 2b/subtract-> *Function-size 4/r32/esp 89/<- %ecx 4/r32/esp (zero-out %ecx *Function-size) + # var vars/ebx : (ref stack (address var) 16) + 81 5/subop/subtract %esp 0x10/imm32 + 68/push 0x10/imm32/length + 68/push 0/imm32/top + 89/<- %ebx 4/r32/esp # convert - (populate-mu-function-header _test-input-stream %ecx) + (populate-mu-function-header _test-input-stream %ecx %ebx) # check result (check-strings-equal *ecx "foo" "F - test-function-header-with-arg/name") # Function-name # edx : (handle list var) = result->inouts @@ -996,8 +1000,13 @@ test-function-header-with-multiple-args: 2b/subtract-> *Function-size 4/r32/esp 89/<- %ecx 4/r32/esp (zero-out %ecx *Function-size) + # var vars/ebx : (ref stack (address var) 16) + 81 5/subop/subtract %esp 0x10/imm32 + 68/push 0x10/imm32/length + 68/push 0/imm32/top + 89/<- %ebx 4/r32/esp # convert - (populate-mu-function-header _test-input-stream %ecx) + (populate-mu-function-header _test-input-stream %ecx %ebx) # check result (check-strings-equal *ecx "foo") # Function-name # edx : (handle list var) = result->inouts @@ -1038,8 +1047,13 @@ test-function-with-multiple-args-and-outputs: 2b/subtract-> *Function-size 4/r32/esp 89/<- %ecx 4/r32/esp (zero-out %ecx *Function-size) + # var vars/ebx : (ref stack (address var) 16) + 81 5/subop/subtract %esp 0x10/imm32 + 68/push 0x10/imm32/length + 68/push 0/imm32/top + 89/<- %ebx 4/r32/esp # convert - (populate-mu-function-header _test-input-stream %ecx) + (populate-mu-function-header _test-input-stream %ecx %ebx) # check result (check-strings-equal *ecx "foo") # Function-name # edx : (handle list var) = result->inouts @@ -1731,7 +1745,7 @@ test-is-identifier-hyphen: 5d/pop-to-ebp c3/return -populate-mu-function-body: # in : (address buffered-file), out : (handle function) +populate-mu-function-body: # in : (address buffered-file), out : (handle function), vars : (address stack (handle var)) # . prologue 55/push-ebp 89/<- %ebp 4/r32/esp @@ -1743,8 +1757,8 @@ populate-mu-function-body: # in : (address buffered-file), out : (handle functi 8b/-> *(ebp+8) 6/r32/esi # edi = out 8b/-> *(ebp+0xc) 7/r32/edi - # var eax : (handle block) = parse-mu-block(in) - (parse-mu-block %esi) # => eax + # var eax : (handle block) = parse-mu-block(in, vars) + (parse-mu-block %esi *(ebp+0x10)) # => eax # out->body = eax 89/<- *(edi+0x10) 0/r32/eax # Function-body $populate-mu-function-body:end: @@ -1758,7 +1772,7 @@ $populate-mu-function-body:end: c3/return # parses a block, assuming that the leading '{' has already been read by the caller -parse-mu-block: # in : (address buffered-file) -> result/eax : (handle block) +parse-mu-block: # in : (address buffered-file), vars : (address stack (handle var)) -> result/eax : (handle block) # pseudocode: # var line : (ref stream byte 512) # var word-slice : (ref slice) @@ -1775,18 +1789,18 @@ parse-mu-block: # in : (address buffered-file) -> result/eax : (handle block) # continue # else if slice-equal?(word-slice, "{") # assert(no-tokens-in(line)) - # block = parse-mu-block(in) + # block = parse-mu-block(in, vars) # append-to-block(result, block) # else if slice-equal?(word-slice, "}") # break # else if slice-ends-with?(word-slice, ":") - # named-block = parse-mu-named-block(word-slice, line, in) + # named-block = parse-mu-named-block(word-slice, line, in, vars) # append-to-block(result, named-block) # else if slice-equal?(word-slice, "var") - # var-def = parse-mu-var-def(line) + # var-def = parse-mu-var-def(line, vars) # append-to-block(result, var-def) # else - # stmt = parse-mu-stmt(line) + # stmt = parse-mu-stmt(line, vars) # append-to-block(result, stmt) # return result # @@ -1850,7 +1864,7 @@ $parse-mu-block:check-for-block: 74/jump-if-equal break/disp8 (check-no-tokens-left %ecx) # parse new block and append - (parse-mu-block *(ebp+8)) # => eax + (parse-mu-block *(ebp+8) *(ebp+0xc)) # => eax (append-to-block %edi %eax) e9/jump $parse-mu-block:line-loop/disp32 } @@ -1870,7 +1884,7 @@ $parse-mu-block:check-for-named-block: 3d/compare-eax-and 0x23/imm32/hash 0f 85/jump-if-not-equal break/disp32 # - (parse-mu-named-block %edx %ecx *(ebp+8)) # => eax + (parse-mu-named-block %edx %ecx *(ebp+8) *(ebp+0xc)) # => eax (append-to-block %edi %eax) e9/jump $parse-mu-block:line-loop/disp32 } @@ -1881,13 +1895,13 @@ $parse-mu-block:check-for-var: 3d/compare-eax-and 0/imm32 74/jump-if-equal break/disp8 # - (parse-mu-var-def %ecx) # => eax + (parse-mu-var-def %ecx *(ebp+0xc)) # => eax (append-to-block %edi %eax) e9/jump $parse-mu-block:line-loop/disp32 } $parse-mu-block:regular-stmt: # otherwise - (parse-mu-stmt %ecx) # => eax + (parse-mu-stmt %ecx *(ebp+0xc)) # => eax (append-to-block Heap %edi %eax) e9/jump loop/disp32 } # end line loop @@ -1966,7 +1980,7 @@ $check-no-tokens-left:end: 5d/pop-to-ebp c3/return -parse-mu-named-block: # name : (address slice), first-line : (address stream byte), in : (address buffered-file) -> result/eax : (handle stmt) +parse-mu-named-block: # name : (address slice), first-line : (address stream byte), in : (address buffered-file), vars : (address stack (handle var)) -> result/eax : (handle stmt) # pseudocode: # var line : (ref stream byte 512) # var word-slice : (ref slice) @@ -1983,18 +1997,18 @@ parse-mu-named-block: # name : (address slice), first-line : (address stream by # if slice-empty?(word-slice) # end of line # break # else if slice-equal?(word-slice, "{") - # block = parse-mu-block(in) + # block = parse-mu-block(in, vars) # append-to-block(result, block) # else if slice-equal?(word-slice, "}") # break # else if slice-ends-with?(word-slice, ":") - # named-block = parse-mu-named-block(word-slice, in) + # named-block = parse-mu-named-block(word-slice, in, vars) # append-to-block(result, named-block) # else if slice-equal?(word-slice, "var") - # var-def = parse-mu-var-def(line) + # var-def = parse-mu-var-def(line, vars) # append-to-block(result, var-def) # else - # stmt = parse-mu-stmt(line) + # stmt = parse-mu-stmt(line, vars) # append-to-block(result, stmt) # return result # @@ -2010,7 +2024,7 @@ $parse-mu-named-block:end: 5d/pop-to-ebp c3/return -parse-mu-var-def: # line : (address stream byte) -> result/eax : (handle stmt) +parse-mu-var-def: # line : (address stream byte), vars : (address stack (handle var)) -> result/eax : (handle stmt) # pseudocode: # # . prologue @@ -2025,17 +2039,16 @@ $parse-mu-var-def:end: 5d/pop-to-ebp c3/return -parse-mu-stmt: # line : (address stream byte) -> result/eax : (handle stmt) +parse-mu-stmt: # line : (address stream byte), vars : (address stack (handle var)) -> result/eax : (handle stmt) # pseudocode: # var name : (ref slice) - # var v : (ref var) # result = allocate(Heap, Stmt-size) # if stmt-has-outputs?(line) # while true # name = next-word(line) # if (name == '<-') break # assert(is-identifier?(name)) - # v = parse-var(name) + # var v : (handle var) = lookup-var(name, vars) # result->outputs = append(result->outputs, v) # result->name = slice-to-string(next-word(line)) # while true @@ -2080,7 +2093,7 @@ $parse-mu-stmt:read-outputs: 3d/compare-eax-and 0/imm32 0f 84/jump-if-equal $parse-mu-stmt:abort/disp32 # - (parse-var Heap %ecx) # => eax + (lookup-var %ecx *(ebp+0xc)) # => eax (append-list Heap %eax *(edi+0xc)) # Stmt1-outputs => eax 89/<- *(edi+0xc) 0/r32/eax # Stmt1-outputs e9/jump loop/disp32 @@ -2103,7 +2116,7 @@ $parse-mu-stmt:read-inouts: 3d/compare-eax-and 0/imm32 0f 85/jump-if-not-equal $parse-mu-stmt:abort2/disp32 # - (parse-var Heap %ecx) # => eax # TODO: parse-var-or-literal + (lookup-var %ecx *(ebp+0xc)) # => eax # TODO: parse-var-or-literal (append-list Heap %eax *(edi+8)) # Stmt1-inouts => eax 89/<- *(edi+8) 0/r32/eax # Stmt1-inouts e9/jump loop/disp32 @@ -2192,29 +2205,88 @@ $stmt-has-outputs:end: 5d/pop-to-ebp c3/return -parse-var: # ad: allocation-descriptor, name: (address slice) -> result/eax: (handle var) +lookup-var: # name: (address slice), vars : (address stack (handle var)) -> result/eax: (handle var) + # pseudocode: + # var curr : (address handle var) = &vars->data[vars->top - 4] + # var min = vars->data + # while curr >= min + # var v : (handle var) = *curr + # if v->name == name + # return v + # abort + # # . prologue 55/push-ebp 89/<- %ebp 4/r32/esp # . save registers 51/push-ecx - # ecx = slice-to-string(name) - 8b/-> *(ebp+0xc) 1/r32/ecx + 52/push-edx + 53/push-ebx + 56/push-esi + # var target/ecx : (handle array byte) = slice-to-string(name) + 8b/-> *(ebp+8) 1/r32/ecx (slice-to-string Heap %ecx) # => eax 89/<- %ecx 0/r32/eax - (allocate *(ebp+8) *Var-size) # => eax - (zero-out %eax *Var-size) - 89/<- *eax 1/r32/ecx # Var-name - # var->type = int - c7 0/subop/copy *(eax+4) 1/imm32/int-type # Var-type -$parse-var:end: + # esi = vars + 8b/-> *(ebp+0xc) 6/r32/esi + # ebx = vars->top + 8b/-> *esi 3/r32/ebx + # if (vars->top > vars->length) abort + 3b/compare 0/r32/eax *(esi+4) + 0f 8f/jump-if-greater $lookup-var:error1/disp32 + # var min/edx : (address handle var) = vars->data + 8d/copy-address *(esi+8) 2/r32/edx + # var curr/ebx : (address handle var) = &vars->data[vars->top - 4] + 81 5/subop/subtract %ebx 4/imm32 + 8d/copy-address *(esi+ebx+8) 3/r32/ebx + { + # if (curr < min) abort + 39/compare %ebx 2/r32/edx + 0f 82/jump-if-lesser-unsigned $lookup-var:error2/disp32 + # var v/eax : (handle var) = *curr + 8b/-> *ebx 0/r32/eax + # if (v->name == name) break + (string-equal? *eax %ecx) # Var-name Var-name + 3d/compare-eax-and 0/imm32 + 75/jump-if-not-equal break/disp8 + 8b/-> *(ebx+4) 3/r32/ebx # List-next + e9/jump loop/disp32 + } + # return *curr + 8b/-> *ebx 0/r32/eax +$lookup-var:end: # . restore registers + 5e/pop-to-esi + 5b/pop-to-ebx + 5a/pop-to-edx 59/pop-to-ecx # . epilogue 89/<- %esp 5/r32/ebp 5d/pop-to-ebp c3/return +$lookup-var:error1: + (write-buffered Stderr "malformed stack when looking up '") + (write-slice-buffered Stderr *(ebp+8)) + (write-buffered Stderr "'\n") + (flush Stderr) + # . syscall(exit, 1) + bb/copy-to-ebx 1/imm32 + b8/copy-to-eax 1/imm32/exit + cd/syscall 0x80/imm8 + # never gets here + +$lookup-var:error2: + (write-buffered Stderr "unknown variable '") + (write-slice-buffered Stderr *(ebp+8)) + (write-buffered Stderr "'\n") + (flush Stderr) + # . syscall(exit, 1) + bb/copy-to-ebx 1/imm32 + b8/copy-to-eax 1/imm32/exit + cd/syscall 0x80/imm8 + # never gets here + test-parse-mu-stmt: # 'increment n' # . prologue @@ -2223,8 +2295,22 @@ test-parse-mu-stmt: # setup (clear-stream _test-input-stream) (write _test-input-stream "increment n\n") + # var vars/ecx : (ref stack (address var) 4) + 81 5/subop/subtract %esp 0x10/imm32 + 68/push 0x10/imm32/length + 68/push 0/imm32/top + 89/<- %ecx 4/r32/esp + (clear-stack %ecx) + # var v/edx : (ref var) + 81 5/subop/subtract %esp 0x14/imm32 # Var-size + 89/<- %edx 4/r32/esp + (zero-out %edx 0x14) + # v->name = "n" + c7 0/subop/copy *edx "n"/imm32 # Var-name + # + (push %ecx %edx) # convert - (parse-mu-stmt _test-input-stream) + (parse-mu-stmt _test-input-stream %ecx) # check result (check-strings-equal *(eax+4) "increment" "F - test-parse-mu-stmt/name") # Stmt1-operation # edx : (handle list var) = result->inouts @@ -2584,7 +2670,7 @@ $emit-subx-block:check-empty: $emit-subx-block:stmt: 81 7/subop/compare %esi 0/imm32 74/jump-if-equal break/disp8 - (emit-subx-statement *(ebp+8) *esi 0 Primitives 0) # TODO: initialize vars and functions + (emit-subx-statement *(ebp+8) *esi Primitives 0) (write-buffered *(ebp+8) Newline) 8b/-> *(esi+4) 6/r32/esi # List-next eb/jump loop/disp8 @@ -2597,7 +2683,7 @@ $emit-subx-block:end: 5d/pop-to-ebp c3/return -emit-subx-statement: # out : (address buffered-file), stmt : (handle statement), vars : (handle stack var), primitives : (handle primitive), functions : (handle function) +emit-subx-statement: # out : (address buffered-file), stmt : (handle statement), primitives : (handle primitive), functions : (handle function) # . prologue 55/push-ebp 89/<- %ebp 4/r32/esp @@ -2607,19 +2693,19 @@ emit-subx-statement: # out : (address buffered-file), stmt : (handle statement) # if stmt matches a primitive, emit it { $emit-subx-statement:primitive: - (find-matching-primitive *(ebp+0x14) *(ebp+0xc)) # primitives, stmt => curr/eax + (find-matching-primitive *(ebp+0x10) *(ebp+0xc)) # primitives, stmt => curr/eax 3d/compare-eax-and 0/imm32 74/jump-if-equal break/disp8 - (emit-subx-primitive *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax) # out, stmt, vars, curr + (emit-subx-primitive *(ebp+8) *(ebp+0xc) %eax) # out, stmt, curr e9/jump $emit-subx-statement:end/disp32 } # else if stmt matches a function, emit a call to it { $emit-subx-statement:call: - (find-matching-function *(ebp+0x18) *(ebp+0xc)) # functions, stmt => curr/eax + (find-matching-function *(ebp+0x14) *(ebp+0xc)) # functions, stmt => curr/eax 3d/compare-eax-and 0/imm32 74/jump-if-equal break/disp8 - (emit-subx-call *(ebp+8) *(ebp+0xc) *(ebp+0x10) %eax) # out, stmt, vars, curr + (emit-subx-call *(ebp+8) *(ebp+0xc) %eax) # out, stmt, curr e9/jump $emit-subx-statement:end/disp32 } # else abort @@ -2760,7 +2846,7 @@ Lit-var: 0/imm32/no-register == code -emit-subx-primitive: # out : (address buffered-file), stmt : (handle statement), vars : (handle variable), primitive : (handle function) +emit-subx-primitive: # out : (address buffered-file), stmt : (handle statement), primitive : (handle function) # . prologue 55/push-ebp 89/<- %ebp 4/r32/esp @@ -2768,7 +2854,7 @@ emit-subx-primitive: # out : (address buffered-file), stmt : (handle statement) 50/push-eax 51/push-ecx # ecx = primitive - 8b/-> *(ebp+0x14) 1/r32/ecx + 8b/-> *(ebp+0x10) 1/r32/ecx # emit primitive name (write-buffered *(ebp+8) *(ecx+0xc)) # Primitive-subx-name # emit rm32 if necessary @@ -2915,7 +3001,7 @@ $emit-subx-imm32:end: 5d/pop-to-ebp c3/return -emit-subx-call: # out : (address buffered-file), stmt : (handle statement), vars : (handle variable), callee : (handle function) +emit-subx-call: # out : (address buffered-file), stmt : (handle statement), callee : (handle function) # . prologue 55/push-ebp 89/<- %ebp 4/r32/esp @@ -2925,7 +3011,7 @@ emit-subx-call: # out : (address buffered-file), stmt : (handle statement), var # (write-buffered *(ebp+8) "(") # - emit function name - 8b/-> *(ebp+0x14) 1/r32/ecx + 8b/-> *(ebp+0x10) 1/r32/ecx (write-buffered *(ebp+8) *(ecx+4)) # Function-subx-name # - emit arguments # var curr/ecx : (handle list var) = stmt->inouts @@ -3306,11 +3392,6 @@ test-emit-subx-statement-primitive: 68/push 1/imm32/type-int 68/push "foo"/imm32 89/<- %ecx 4/r32/esp - # var vars/edx : (ref stack 1) - 51/push-ecx/var-foo - 68/push 1/imm32/data-length - 68/push 1/imm32/top - 89/<- %edx 4/r32/esp # var operand/ebx : (ref list var) 68/push 0/imm32/next 51/push-ecx/var-foo @@ -3333,7 +3414,7 @@ test-emit-subx-statement-primitive: 68/push "increment"/imm32/name 89/<- %ebx 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi %edx %ebx 0) + (emit-subx-statement _test-output-buffered-file %esi %ebx 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -3379,11 +3460,6 @@ test-emit-subx-statement-primitive-register: 68/push 1/imm32/type-int 68/push "foo"/imm32 89/<- %ecx 4/r32/esp - # var vars/edx : (ref stack 1) - 51/push-ecx/var-foo - 68/push 1/imm32/data-length - 68/push 1/imm32/top - 89/<- %edx 4/r32/esp # var operand/ebx : (ref list var) 68/push 0/imm32/next 51/push-ecx/var-foo @@ -3417,7 +3493,7 @@ test-emit-subx-statement-primitive-register: 68/push "increment"/imm32/name 89/<- %ebx 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi %edx %ebx 0) + (emit-subx-statement _test-output-buffered-file %esi %ebx 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -3466,11 +3542,6 @@ test-emit-subx-statement-select-primitive: 68/push 1/imm32/type-int 68/push "foo"/imm32 89/<- %ecx 4/r32/esp - # var vars/edx : (ref stack 1) - 51/push-ecx/var-foo - 68/push 1/imm32/data-length - 68/push 1/imm32/top - 89/<- %edx 4/r32/esp # var real-outputs/edi : (ref list var) 68/push 0/imm32/next 51/push-ecx/var-foo @@ -3514,7 +3585,7 @@ test-emit-subx-statement-select-primitive: 68/push "increment"/imm32/name 89/<- %ebx 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi %edx %ebx 0) + (emit-subx-statement _test-output-buffered-file %esi %ebx 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -3563,11 +3634,6 @@ test-emit-subx-statement-select-primitive-2: 68/push 1/imm32/type-int 68/push "foo"/imm32 89/<- %ecx 4/r32/esp - # var vars/edx : (ref stack 1) - 51/push-ecx/var-foo - 68/push 1/imm32/data-length - 68/push 1/imm32/top - 89/<- %edx 4/r32/esp # var inouts/edi : (ref list var) 68/push 0/imm32/next 51/push-ecx/var-foo @@ -3611,7 +3677,7 @@ test-emit-subx-statement-select-primitive-2: 68/push "increment"/imm32/name 89/<- %ebx 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi %edx %ebx 0) + (emit-subx-statement _test-output-buffered-file %esi %ebx 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -3654,11 +3720,6 @@ test-increment-register: 68/push 1/imm32/type-int 68/push "foo"/imm32 89/<- %ecx 4/r32/esp - # var vars/edx : (ref stack 1) - 51/push-ecx/var-foo - 68/push 1/imm32/data-length - 68/push 1/imm32/top - 89/<- %edx 4/r32/esp # var real-outputs/edi : (ref list var) 68/push 0/imm32/next 51/push-ecx/var-foo @@ -3671,7 +3732,7 @@ test-increment-register: 68/push 1/imm32 89/<- %esi 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi %edx Primitives 0) + (emit-subx-statement _test-output-buffered-file %esi Primitives 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -3714,11 +3775,6 @@ test-increment-var: 68/push 1/imm32/type-int 68/push "foo"/imm32 89/<- %ecx 4/r32/esp - # var vars/edx : (ref stack 1) - 51/push-ecx/var-foo - 68/push 1/imm32/data-length - 68/push 1/imm32/top - 89/<- %edx 4/r32/esp # var inouts/edi : (ref list var) 68/push 0/imm32/next 51/push-ecx/var-foo @@ -3731,7 +3787,7 @@ test-increment-var: 68/push 1/imm32 89/<- %esi 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi %edx Primitives 0) + (emit-subx-statement _test-output-buffered-file %esi Primitives 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -3787,7 +3843,7 @@ test-add-reg-to-reg: 68/push 1/imm32 89/<- %esi 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi 0 Primitives 0) + (emit-subx-statement _test-output-buffered-file %esi Primitives 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -3843,7 +3899,7 @@ test-add-reg-to-mem: 68/push 1/imm32 89/<- %esi 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi 0 Primitives 0) + (emit-subx-statement _test-output-buffered-file %esi Primitives 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -3899,7 +3955,7 @@ test-add-mem-to-reg: 68/push 1/imm32 89/<- %esi 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi 0 Primitives 0) + (emit-subx-statement _test-output-buffered-file %esi Primitives 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -3955,7 +4011,7 @@ test-add-literal-to-reg: 68/push 1/imm32 89/<- %esi 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi 0 Primitives 0) + (emit-subx-statement _test-output-buffered-file %esi Primitives 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -4011,7 +4067,7 @@ test-add-literal-to-mem: 68/push 1/imm32 89/<- %esi 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi 0 Primitives 0) + (emit-subx-statement _test-output-buffered-file %esi Primitives 0) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -4059,11 +4115,6 @@ test-emit-subx-statement-function-call: 68/push 1/imm32/type-int 68/push "foo"/imm32 89/<- %ecx 4/r32/esp - # var vars/edx = (ref stack 1) - 51/push-ecx/var-foo - 68/push 1/imm32/data-length - 68/push 1/imm32/top - 89/<- %edx 4/r32/esp # var operands/esi : (ref list var) 68/push 0/imm32/next 51/push-ecx/var-foo @@ -4084,7 +4135,7 @@ test-emit-subx-statement-function-call: 68/push "f"/imm32/name 89/<- %ebx 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi %edx 0 %ebx) + (emit-subx-statement _test-output-buffered-file %esi 0 %ebx) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^") @@ -4118,11 +4169,6 @@ test-emit-subx-statement-function-call-with-literal-arg: 68/push 0/imm32/type-literal 68/push "34"/imm32 89/<- %ecx 4/r32/esp - # var vars/edx = (ref stack 1) - 51/push-ecx/var-foo - 68/push 1/imm32/data-length - 68/push 1/imm32/top - 89/<- %edx 4/r32/esp # var operands/esi : (ref list var) 68/push 0/imm32/next 51/push-ecx/var-foo @@ -4143,7 +4189,7 @@ test-emit-subx-statement-function-call-with-literal-arg: 68/push "f"/imm32/name 89/<- %ebx 4/r32/esp # convert - (emit-subx-statement _test-output-buffered-file %esi %edx 0 %ebx) + (emit-subx-statement _test-output-buffered-file %esi 0 %ebx) (flush _test-output-buffered-file) #? # dump _test-output-stream {{{ #? (write 2 "^")