Invalid behavior in some functions with return parameters

[zapateo]

Source code

package main

import (
        "fmt"
)

func f() (err error) {
        defer func() {
                _ = recover()
        }()
        var i int
        _ = 1 / i
        return nil
}

func main() {
        fmt.Println(f())
}

Scriggo output

runtime error: integer divide by zero

gc output

<nil>

[gazerro]

The function f does not panic, it returns the value returned from the recover built-in instead of nil.

The disassembled code is

Package main

Func f() (g1 error)
	; regs(3,0,0,3)
	Move nil g2
	Move g2 g1
	Func g3 func()
		; regs(0,0,0,1)
		Recover g1   <-- ERROR: it writes into register g1 which is the named result
		Return
	Move g3 g2
	Defer g2 _ _ _ _	; func()
	Move 0 i1
	Load 1 i3
	Div i3 i1 i2
	Move nil g2
	Move g2 g1
	Return
	Return

Func main()
	; regs(0,0,0,2)
	Call main.f _ _ _ g1	; func() (g1 error)
	Move g1 g2
	Print g2
	Typify string "\n" g1
	Print g1
	Return

The error is not due to the recover built-in. Replacing it with the make built-in, the error is the same:

package main

func f() (err error) {
        defer func() {
                _ = make([]int, 1)
        }()
        return nil
}

func main() {
        println(f())
}

and disassembled:

Package main

Func f() (g1 error)
	; regs(0,0,0,3)
	Move nil g2
	Move g2 g1
	Func g3 func()
		; regs(0,0,0,1)
		MakeSlice int 1 1 g1   <-- ERROR: it writes into register g1 which is the named result
		Return
	Move g3 g2
	Defer g2 _ _ _ _	; func()
	Move nil g2
	Move g2 g1
	Return
	Return

Func main()
	; regs(0,0,0,2)
	Call main.f _ _ _ g1	; func() (g1 error)
	Move g1 g2
	Print g2
	Typify string "\n" g1
	Print g1
	Return

[zapateo]

Another version of this issue:

package main

import (
        "fmt"
)

func s() []int { return []int{} }

func f() (err error) {
        defer func() {
                _ = recover()
                _ = s()
        }()
        var i int
        _ = 1 / i
        return nil
}

func main() {
        fmt.Println(f())
}

Yet another version of the issue:

package main

import (
	"fmt"
)

func f() interface{} {
	defer func() {
		_ = []int{}
		recover()
	}()
	panic(0)
}

func main() {
	fmt.Println(f())
}

May be the problem related to the finalizer?

[zapateo]

A simplified version of the issue:

package main

import (
	"fmt"
)

func f() []int {

	defer func() {
		recover()
	}()
	panic("")

}

func main() {
	fmt.Println(f())
}

[zapateo]

First problem

The problem of uninitialized registers may be solved by changing prepareFunctionBodyParameters (see the PR associated to this issue).

Second problem (just an optimization)

The code above should be executed only if the function has at least one defer statement in it; otherwise, it's useful. This information may be returned by the type checker.

Third problem

Even implementing the above changes, the problem continues to arise with some tests. This appears to be caused by something wrong in the emission of the statement defer; perhaps it is related to stack shift.

[zapateo]

@gazerro

The linked PR fixes the problem of registers initialization, but still remains something related to the defer statement.

This code shows the invalid behaviour:

package main

import (
	"fmt"
)

func f() interface{} {
	defer func() {
		_ = []int{}
		recover()
	}()
	panic(0)
}

func main() {
	fmt.Println(f())
}

It should print <nil> but it prints [] instead; this is probably caused by the deferred function that writes the []int value on a register owned by the f function.