The need to keep the address of the load alive for longer definitely throws a wrench in this. We'd need some analysis to see if it is even worthwhile.

So far we've been maintaining the invariant that if you do:

x := *p
if x != 0 {
   ... use x ...
}

Then we guarantee that at the use of x, it is still nonzero. In the presence of reloading and races, that is no longer true.
That may sound like not much of a problem, because if there's a race we're allowed to do anything. But it isn't that simple - there are races where we can't just say "you lose". For instance, the code in sync/mutex.go:tryLock depends on old := m.state only happening once. if old was reloaded from m.state, bad things happen.

Fun related issue: #48222

In this case, we would only reload in a situation in which the program already includes a load—we are letting regalloc undo the work of CSE. Alternatively, we could try to guess when CSEing a load will be worse than leaving it.

I can tell you that refusing to CSE anything with a final memory arg is a bad idea. :)

That's kind of the problem in #48222 - there's no way to tell the difference between a program with 2 loads that were CSEd, in which case it would be ok to split it back up, and a program with a single load which we want to split up into 2 loads, in which case that splitting can be problematic. If you want to split loads back up, we'd have to keep track of its progenitor loads somehow.

I agree that the easier thing might be to not CSE loads in cases where we think it might introduce too much register pressure. But "easier" is a relative term here, both solutions seem hard.