cmd/compile: mark empty block preemptible

Currently, a block's control instruction gets the liveness info
of the last Value in the block. However, for an empty block, the
control instruction gets the invalid liveness info and therefore
not preemptible. One example is empty infinite loop, which has
only a control instruction. The control instruction being non-
preemptible makes the whole loop non-preemptible.

Fix this by using a different, preemptible liveness info for
empty block's control. We can choose an arbitrary preemptible
liveness info, as at run time we don't really use the liveness
map at that instruction.

As before, if the last Value in the block is non-preemptible, so
is the block control. For example, the conditional branch in the
write barrier test block is still non-preemptible.

Also, only update liveness info if we are actually emitting
instructions. So zero-width Values' liveness info (which are
always invalid) won't affect the block control's liveness info.
For example, if the last Values in a block is a tuple-generating
operation and a Select, the block control instruction is still
preemptible.

Fixes #35923.

Change-Id: Ic5225f3254b07e4955f7905329b544515907642b
Reviewed-on: https://go-review.googlesource.com/c/go/+/209659
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>

src/cmd/compile/internal/gc/ssa.go

@@ -5968,23 +5968,22 @@ func genssa(f *ssa.Func, pp *Progs) {
 	// Emit basic blocks
 	for i, b := range f.Blocks {
 		s.bstart[b.ID] = s.pp.next
-		s.pp.nextLive = LivenessInvalid
 		s.lineRunStart = nil
 
+		// Attach a "default" liveness info. Normally this will be
+		// overwritten in the Values loop below for each Value. But
+		// for an empty block this will be used for its control
+		// instruction. We won't use the actual liveness map on a
+		// control instruction. Just mark it something that is
+		// preemptible.
+		s.pp.nextLive = LivenessIndex{-1, -1}
+
 		// Emit values in block
 		thearch.SSAMarkMoves(&s, b)
 		for _, v := range b.Values {
 			x := s.pp.next
 			s.DebugFriendlySetPosFrom(v)
-			// Attach this safe point to the next
-			// instruction.
-			s.pp.nextLive = s.livenessMap.Get(v)
-
-			// Remember the liveness index of the first defer call of
-			// the last defer exit
-			if v.Block.Func.LastDeferExit != nil && v == v.Block.Func.LastDeferExit {
-				s.lastDeferLiveness = s.pp.nextLive
-			}
+
 			switch v.Op {
 			case ssa.OpInitMem:
 				// memory arg needs no code
@@ -6018,12 +6017,22 @@ func genssa(f *ssa.Func, pp *Progs) {
 				inlMarksByPos[pos] = append(inlMarksByPos[pos], p)
 
 			default:
-				// let the backend handle it
+				// Attach this safe point to the next
+				// instruction.
+				s.pp.nextLive = s.livenessMap.Get(v)
+
+				// Remember the liveness index of the first defer call of
+				// the last defer exit
+				if v.Block.Func.LastDeferExit != nil && v == v.Block.Func.LastDeferExit {
+					s.lastDeferLiveness = s.pp.nextLive
+				}
+
 				// Special case for first line in function; move it to the start.
 				if firstPos != src.NoXPos {
 					s.SetPos(firstPos)
 					firstPos = src.NoXPos
 				}
+				// let the backend handle it
 				thearch.SSAGenValue(&s, v)
 			}
 

src/runtime/testdata/testprog/preempt.go

@@ -34,13 +34,19 @@ func AsyncPreempt() {
 	// This is an especially interesting case for
 	// LR machines.
 	go func() {
-		atomic.StoreUint32(&ready2, 1)
+		atomic.AddUint32(&ready2, 1)
 		frameless()
 	}()
+	// Also test empty infinite loop.
+	go func() {
+		atomic.AddUint32(&ready2, 1)
+		for {
+		}
+	}()
 
 	// Wait for the goroutine to stop passing through sync
 	// safe-points.
-	for atomic.LoadUint32(&ready) == 0 || atomic.LoadUint32(&ready2) == 0 {
+	for atomic.LoadUint32(&ready) == 0 || atomic.LoadUint32(&ready2) < 2 {
 		runtime.Gosched()
 	}