Fix codegen correctness issues: register clobbering, >6 params, GOSUB overflow

- Fix argument register clobbering in function calls by evaluating all
  args to stack temporaries before loading registers
- Fix LEFT$/RIGHT$/MID$ builtins to use callee-saved registers (r12-r14)
- Support >6 parameters in SUB/FUNCTION via stack-based overflow args
- Add GOSUB stack overflow protection with runtime error handler
- Increase GOSUB stack from 1K to 64K entries (512KB)
- Add expression nesting depth warning at 256 levels
- Use consistent sub rsp/add rsp pattern for string concatenation temps
- Add integration tests for all fixes

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: jgarzik

src/codegen.rs

@@ -12,3 +12,4 @@ _chr_buf: .skip 2
 _str_buf: .skip 64
 _rng_state: .quad 0x12345678DEADBEEF
 _cls_seq: .asciz "\033[2J\033[H"
+_gosub_overflow_msg: .asciz "Error: GOSUB stack overflow\n"

src/runtime/sysv/data_defs.s

@@ -130,3 +130,22 @@ _rt_print_float:
 .Lprint_float_done:
     leave
     ret
+
+# ------------------------------------------------------------------------------
+# _rt_gosub_overflow - Handle GOSUB stack overflow error
+# ------------------------------------------------------------------------------
+# Called when the GOSUB return stack is exhausted. Prints an error message
+# and terminates the program with exit code 1.
+#
+# Arguments: none
+# Returns: never (calls exit)
+# ------------------------------------------------------------------------------
+.globl _rt_gosub_overflow
+_rt_gosub_overflow:
+    push rbp
+    mov rbp, rsp
+    lea rdi, [rip + _gosub_overflow_msg]
+    xor eax, eax
+    call {libc}printf
+    mov edi, 1              # exit code 1
+    call {libc}exit

src/runtime/sysv/print.s

@@ -15,3 +15,7 @@
 _fmt_int: .asciz "%lld"
 _fmt_float: .asciz "%g"
 
+# Error messages
+_gosub_overflow_msg: .ascii "Error: GOSUB stack overflow\r\n"
+.equ _gosub_overflow_msg_len, 29
+

src/runtime/win64-native/data_defs.s

@@ -178,3 +178,33 @@ _rt_print_float:
 
     leave
     ret
+
+# ------------------------------------------------------------------------------
+# _rt_gosub_overflow - Handle GOSUB stack overflow error
+# ------------------------------------------------------------------------------
+# Called when the GOSUB return stack is exhausted. Prints an error message
+# and terminates the program with exit code 1.
+#
+# Arguments: none
+# Returns: never (calls ExitProcess)
+# ------------------------------------------------------------------------------
+.globl _rt_gosub_overflow
+_rt_gosub_overflow:
+    push rbp
+    mov rbp, rsp
+    sub rsp, 48
+
+    # Get stdout handle
+    lea rax, [rip + _stdout_handle]
+    mov rcx, [rax]
+
+    # WriteFile(handle, message, length, &bytesWritten, NULL)
+    lea rdx, [rip + _gosub_overflow_msg]
+    mov r8, _gosub_overflow_msg_len
+    lea r9, [rip + _bytes_written]
+    mov QWORD PTR [rsp + 32], 0
+    call WriteFile
+
+    # ExitProcess(1)
+    mov ecx, 1
+    call ExitProcess

src/runtime/win64-native/print.s

@@ -280,3 +280,54 @@ PRINT "after"
     .unwrap();
     assert_eq!(output.trim(), "before");
 }
+
+#[test]
+fn test_gosub_many_calls() {
+    // Test GOSUB with many calls to stress the return stack
+    let output = compile_and_run(
+        r#"
+X = 0
+FOR I = 1 TO 500
+    GOSUB 100
+NEXT I
+PRINT X
+END
+
+100 X = X + 1
+RETURN
+"#,
+    )
+    .unwrap();
+    assert_eq!(output.trim(), "500");
+}
+
+#[test]
+fn test_gosub_nested() {
+    // Test nested GOSUB calls
+    let output = compile_and_run(
+        r#"
+GOSUB 100
+PRINT "done"
+END
+
+100 PRINT "L1 start"
+GOSUB 200
+PRINT "L1 end"
+RETURN
+
+200 PRINT "L2 start"
+GOSUB 300
+PRINT "L2 end"
+RETURN
+
+300 PRINT "L3"
+RETURN
+"#,
+    )
+    .unwrap();
+    let lines: Vec<&str> = output.trim().lines().collect();
+    assert_eq!(
+        lines,
+        vec!["L1 start", "L2 start", "L3", "L2 end", "L1 end", "done"]
+    );
+}

tests/control/mod.rs

@@ -53,3 +53,96 @@ END SUB
     .unwrap();
     assert_eq!(output.trim(), "30");
 }
+
+#[test]
+fn test_nested_fn_args() {
+    // Test that nested function calls in arguments don't clobber registers
+    let output = compile_and_run(
+        r#"
+FUNCTION Add(A, B)
+    Add = A + B
+END FUNCTION
+
+FUNCTION Mul(A, B)
+    Mul = A * B
+END FUNCTION
+
+PRINT Add(Mul(2, 3), Mul(4, 5))
+"#,
+    )
+    .unwrap();
+    // 2*3=6, 4*5=20, 6+20=26
+    assert_eq!(output.trim(), "26");
+}
+
+#[test]
+fn test_seven_params() {
+    // Test procedure with 7 parameters (1 more than max register args on SysV)
+    let output = compile_and_run(
+        r#"
+SUB Sum7(A, B, C, D, E, F, G)
+    PRINT A + B + C + D + E + F + G
+END SUB
+
+Sum7(1, 2, 3, 4, 5, 6, 7)
+"#,
+    )
+    .unwrap();
+    // 1+2+3+4+5+6+7 = 28
+    assert_eq!(output.trim(), "28");
+}
+
+#[test]
+fn test_eight_params() {
+    // Test function with 8 parameters (2 more than max register args on SysV)
+    let output = compile_and_run(
+        r#"
+FUNCTION Sum8(A, B, C, D, E, F, G, H)
+    Sum8 = A + B + C + D + E + F + G + H
+END FUNCTION
+
+PRINT Sum8(1, 2, 3, 4, 5, 6, 7, 8)
+"#,
+    )
+    .unwrap();
+    // 1+2+3+4+5+6+7+8 = 36
+    assert_eq!(output.trim(), "36");
+}
+
+#[test]
+fn test_ten_params() {
+    // Test with 10 parameters to ensure multiple overflow args work
+    let output = compile_and_run(
+        r#"
+FUNCTION Sum10(A, B, C, D, E, F, G, H, I, J)
+    Sum10 = A + B + C + D + E + F + G + H + I + J
+END FUNCTION
+
+PRINT Sum10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+"#,
+    )
+    .unwrap();
+    // 1+2+3+4+5+6+7+8+9+10 = 55
+    assert_eq!(output.trim(), "55");
+}
+
+#[test]
+fn test_nested_fn_many_params() {
+    // Test nested function calls with many parameters
+    let output = compile_and_run(
+        r#"
+FUNCTION AddThree(A, B, C)
+    AddThree = A + B + C
+END FUNCTION
+
+FUNCTION MulTwo(A, B)
+    MulTwo = A * B
+END FUNCTION
+
+PRINT AddThree(MulTwo(2, 3), MulTwo(4, 5), MulTwo(6, 7))
+"#,
+    )
+    .unwrap();
+    // 2*3=6, 4*5=20, 6*7=42, 6+20+42=68
+    assert_eq!(output.trim(), "68");
+}

tests/procedures/mod.rs

@@ -62,3 +62,69 @@ fn test_instr_function() {
     let output = compile_and_run(r#"PRINT INSTR("Hello World", "World")"#).unwrap();
     assert_eq!(output.trim(), "7");
 }
+
+#[test]
+fn test_left_with_nested_call() {
+    // Test LEFT$ with nested function call in count argument
+    let output = compile_and_run(
+        r#"
+A$ = "HELLO"
+B$ = "WORLD"
+PRINT LEFT$(A$ + B$, LEN(A$))
+"#,
+    )
+    .unwrap();
+    // A$+B$ = "HELLOWORLD", LEN(A$) = 5, LEFT$ takes first 5 chars
+    assert_eq!(output.trim(), "HELLO");
+}
+
+#[test]
+fn test_right_with_nested_call() {
+    // Test RIGHT$ with nested function call in count argument
+    let output = compile_and_run(
+        r#"
+A$ = "HELLO"
+B$ = "WORLD"
+PRINT RIGHT$(A$ + B$, LEN(B$))
+"#,
+    )
+    .unwrap();
+    // A$+B$ = "HELLOWORLD", LEN(B$) = 5, RIGHT$ takes last 5 chars
+    assert_eq!(output.trim(), "WORLD");
+}
+
+#[test]
+fn test_mid_with_nested_calls() {
+    // Test MID$ with nested function calls in position and count arguments
+    let output = compile_and_run(
+        r#"
+FUNCTION GetStart()
+    GetStart = 2
+END FUNCTION
+
+FUNCTION GetLen()
+    GetLen = 3
+END FUNCTION
+
+PRINT MID$("ABCDEF", GetStart(), GetLen())
+"#,
+    )
+    .unwrap();
+    // MID$("ABCDEF", 2, 3) = "BCD"
+    assert_eq!(output.trim(), "BCD");
+}
+
+#[test]
+fn test_string_concat_multiple() {
+    // Test string concatenation with multiple operands
+    let output = compile_and_run(
+        r#"
+A$ = "Hello"
+B$ = " "
+C$ = "World"
+PRINT A$ + B$ + C$
+"#,
+    )
+    .unwrap();
+    assert_eq!(output.trim(), "Hello World");
+}