/cc @ianlancetaylor @aclements

Works in Go 1.3, fails in every version since. Works with gccgo. Easy to work around. Setting milestone to 1.12.

Kindly paging also @randall77

The easy, shallow fix for this is probably to teach the compiler to do the “wrap in a closure” trick itself. It already does that for a print and some other builtins; this probably just requires adding a special case for (say) any calls in package reflect. Might be a decent starter issue for someone working on the compiler.

It looks like the problem is scanning a goroutine where the top level function is reflect.makeFuncStub, but the goroutine hasn't started yet. There's no frame for reflect.makeFuncStub that the runtime can grab the arg map from. We'd have to grab that map from the ctxt register (or, more precisely, the g.gobuf.ctxt value), like we do with defers.

Here's a simpler repro:

package main

import (
	"reflect"
	"runtime"
)

const N = 100

func main() {
	c := make(chan bool, N)
	for i := 0; i < N; i++ {
		f := reflect.MakeFunc(reflect.TypeOf(((func(*int))(nil))),
			func(args []reflect.Value) []reflect.Value {
				c <- true
				return nil
			}).Interface().(func(*int))
		go f(nil)
	}
	runtime.GC()
	for i := 0; i < N; i++ {
		<-c
	}
}

run with

GOMAXPROCS=1 go run issue25897.go

@josharian I don't think the wrapper strategy will work. At the point of the go statement, the thing we're running is just a closure - we don't know where the implementation comes from. Or are you saying that we should wrap just makeFuncStub in another wrapper function?

Change https://golang.org/cl/180258 mentions this issue: runtime: get map of args of unstarted goroutines like we do for defers