Comment 1:

I guess that gc should moves values above a certain size to the heap.  I thought it
already did that but I couldn't find the code in a quick search.

Labels changed: added repo-main, release-go1.5.

The following does not panic:

func func1() {
    // var a [100000000]int64 // also ok
    a := [100000000]int64{}
    a[1] = 1
}

It seems the temporary on the right is only moved to the heap when it is zero-initialized.

Too late for Go 1.5.

This is probably out of my reach, but I'll write a few notes for the posterity.

In both

a := [100000000]int64{}

and

a := [100000000]int64{1}

the compiler correctly marks a as escaping and moves it to the heap.

The problem is that the for the latter the compiler generates an autotmp_0001 variabile to hold the array literal. autotmps are generated by the Tempname function in gen.go and they're always marked as not escaping (n.Esc = EscNever). For this reason when the compiler computes the stack size of the function (allocauto function in pgen.go), looping over the function variables, a is skipped (because it's marked as escaping), while autotmp_0001 is not. The compiler add the size of autotmp_0001 (which is > 1 GB) to the total stack size, and then at runtime the program calls morestack and it panics because the stack is too big.

This issue (at least in the current form) was fixed by https://go-review.googlesource.com/#/c/22192

Thanks.