package main

type T struct {
	p *int
	i int
}

func f(m map[T]int) {
	m[T{nil, 1}] = 1
	m[T{nil, 2}] = 2
}

If you look at the disassembly of f, we use an autotmp to pass the key to mapassign. Each call to mapassign uses its own temporary. We should reuse these temporaries - they are live only for the duration of the mapassign call.

This situation gets particularly painful for large map initializations in init() functions. There could be thousands of mapassign calls, and each one gets its own temporary. That means really large stack frames and correspondingly large live pointer maps. In fact the live pointer map size is quadratic in source size, as it is proportional to both the number of temporaries and the number of safe points.

There are other places we use temporaries like this, mostly introduced in order.go. We should reuse temps for as many as we can.

Note: I use the weird key in the example to avoid the _fast version for int32, int64, and string. _fast versions don't use an autotmp.

Related: #19751

@josharian @mdempsky @martisch