gollvm/gofrontend: when evaluates x twice in "x op= y", which was detectable if evaluating y affects x.

[xqq0629]

What version of Go are you using (go version)?

$ go version

gollvm

Does this issue reproduce with the latest release?

yes

What operating system and processor architecture are you using (go env)?

go env Output

$ go env

Debian
Intel(R) Xeon(R) Platinum 8260 CPU @ 2.40GHz (Cascade Lake)

What did you do?

error case:

package main
import "fmt"
func mapscase() int {
    one := map[int]int{0: 1299}
    two := map[int]int{0: 2388}

    x := one
    x[0] += func() int {
        x = two
        return 1113
    }()

    return two[0]
}

func main() {
    a := mapscase()
    fmt.Println(a)
}

What did you expect to see?

3501

What did you see instead?

2412
cmd/compile: "x[i] op= y" evaluates x[i] more than once can also be referenced.

Error & Solution

An output of 2412 indicates that x[0] was evaluated twice as follows: once indexing into the old map to read the value 1299, and then once into the new to store the value 1299 + 1113.

gofrontend doesn't consider such case: when evaluates x twice in "x op= y", evaluating y may affect x. In such case, y on the right should be evaluated first and x on the left should be read latter.

[gopherbot]

Change https://go.dev/cl/405394 mentions this issue: fix when "x[i] op= y" evaluates x[i] more than once

[heschi]

cc @thanm

[ianlancetaylor]

I don't think that the language spec provides any guarantees about the order of evaluation of this statement. If you think that it does guarantee the order, can you explain your reasoning? Thanks.

CC @griesemer @mdempsky

[mdempsky]

I think the issue is valid. Clearer repro:

package main

func main() {
	one := map[int]string{0: "one"}
	two := map[int]string{0: "two"}

	x := one
	x[0] += func() string {
		x = two
		return ""
	}()

	println(one[0], two[0])
}

This program should print one two, but with "gccgo (Debian 11.2.0-16+build1) 11.2.0" it prints one one.