vm1: improve function calling (#6)

The "Enter" instruction has been removed and the frame pointer is
now saved by the "Call" instruction.

The "Return" instruction now takes the number of function input
parameters as the second operand. It's used to return the output
values at the correct place in the caller frame, no matter the
number of input parameters.

The tests and the code generator have been updated accordingly.

1 files changed, 43 insertions, 46 deletions

diff --git a/vm1/vm_test.go b/vm1/vm_test.go
index 53b0d07..cea4f29 100644
--- a/vm1/vm_test.go
+++ b/vm1/vm_test.go
@@ -62,60 +62,57 @@ var tests = []struct {
 	start: 0, end: 2, mem: "[6 <nil>]",
 }, { // #02 -- Defining and calling a function in VM.
 	code: [][]int64{
-		{0, Jump, 4},   // 0
-		{0, Enter},     // 1
-		{0, Push, 3},   // 2
-		{0, Return, 1}, // 3
-		{0, Push, 1},   // 4
-		{0, Call, -4},  // 5
-		{0, Exit},      // 6
+		{0, Jump, 3},      // 0
+		{0, Push, 3},      // 1
+		{0, Return, 1, 1}, // 2
+		{0, Push, 1},      // 3
+		{0, Call, -3},     // 4
+		{0, Exit},         // 5
 	},
 	start: 0, end: 1, mem: "[3]",
 }, { // #03 -- Fibonacci numbers, hand written. Showcase recursivity.
 	code: [][]int64{
-		{0, Jump, 18},     // 0, goto 18
-		{0, Enter},        // 1,
-		{0, Fdup, -2},     // 2, [i]
-		{0, Push, 2},      // 3, [i 2]
-		{0, Lower},        // 4, [true/false]
-		{0, JumpTrue, 11}, // 5, [], goto 16
-		{0, Fdup, -2},     // 6  [i]
-		{0, Push, 2},      // 7  [i 2]
-		{0, Sub},          // 8  [(i-2)]
-		{0, Call, -8},     // 9  [fib(i-2)]
-		{0, Fdup, -2},     // 10 [fib(i-2) i]
-		{0, Push, 1},      // 11 [(i-2) i 1]
-		{0, Sub},          // 12 [(i-2) (i-1)]
-		{0, Call, -12},    // 13 [fib(i-2) fib(i-1)]
-		{0, Add},          // 14 [fib(i-2)+fib(i-1)]
-		{0, Return, 1},    // 15 return i
-		{0, Fdup, -2},     // 16 [i]
-		{0, Return, 1},    // 17 return i
-		{0, Push, 6},      // 18 [1]
-		{0, Call, -18},    // 19 [fib(*1)]
-		{0, Exit},         // 20
+		{0, Jump, 17},     // 0
+		{0, Fdup, -2},     // 1  [i]
+		{0, Push, 2},      // 2  [i 2]
+		{0, Lower},        // 3  [true/false]
+		{0, JumpTrue, 11}, // 4  [], goto 16
+		{0, Fdup, -2},     // 5  [i]
+		{0, Push, 2},      // 6  [i 2]
+		{0, Sub},          // 7  [(i-2)]
+		{0, Call, -7},     // 8  [fib(i-2)]
+		{0, Fdup, -2},     // 9  [fib(i-2) i]
+		{0, Push, 1},      // 10 [(i-2) i 1]
+		{0, Sub},          // 11 [(i-2) (i-1)]
+		{0, Call, -11},    // 12 [fib(i-2) fib(i-1)]
+		{0, Add},          // 13 [fib(i-2)+fib(i-1)]
+		{0, Return, 1, 1}, // 14 return i
+		{0, Fdup, -2},     // 15 [i]
+		{0, Return, 1, 1}, // 16 return i
+		{0, Push, 6},      // 17 [1]
+		{0, Call, -17},    // 18 [fib(*1)]
+		{0, Exit},         // 19
 	},
 	start: 0, end: 1, mem: "[8]",
 }, { // #04 -- Fibonacci with some immediate instructions.
 	code: [][]int64{
-		{0, Jump, 15},    // 0, goto 15
-		{0, Enter},       // 1,
-		{0, Fdup, -2},    // 2, [i]
-		{0, Loweri, 2},   // 3, [true/false]
-		{0, JumpTrue, 9}, // 4, [], goto 13
-		{0, Fdup, -2},    // 5  [i]
-		{0, Subi, 2},     // 6  [(i-2)]
-		{0, Call, -6},    // 7  [fib(i-2)]
-		{0, Fdup, -2},    // 8  [fib(i-2) i]
-		{0, Subi, 1},     // 9  [(i-2) (i-1)]
-		{0, Call, -9},    // 10 [fib(i-2) fib(i-1)], call 1
-		{0, Add},         // 11 [fib(i-2)+fib(i-1)]
-		{0, Return, 1},   // 12 return i
-		{0, Fdup, -2},    // 13 [i]
-		{0, Return, 1},   // 14 return i
-		{0, Push, 6},     // 15 [1]
-		{0, Call, -15},   // 16 [fib(*1)], call 1
-		{0, Exit},        // 17
+		{0, Jump, 14},     // 0
+		{0, Fdup, -2},     // 1  [i]
+		{0, Loweri, 2},    // 2  [true/false]
+		{0, JumpTrue, 9},  // 3  [], goto 13
+		{0, Fdup, -2},     // 4  [i]
+		{0, Subi, 2},      // 5  [(i-2)]
+		{0, Call, -5},     // 6  [fib(i-2)]
+		{0, Fdup, -2},     // 7  [fib(i-2) i]
+		{0, Subi, 1},      // 8  [(i-2) (i-1)]
+		{0, Call, -8},     // 9  [fib(i-2) fib(i-1)], call 1
+		{0, Add},          // 10 [fib(i-2)+fib(i-1)]
+		{0, Return, 1, 1}, // 11 return i
+		{0, Fdup, -2},     // 12 [i]
+		{0, Return, 1, 1}, // 13 return i
+		{0, Push, 6},      // 14 [1]
+		{0, Call, -14},    // 15 [fib(*1)], call 1
+		{0, Exit},         // 16
 	},
 	start: 0, end: 1, mem: "[8]",
 }}