Revert "cmd/compile: allow all of the preamble to be preemptible"

This reverts commits

3f3782feed6e0726ddb08afd32dad7d94fbb38c6 (CL 648518)
b386b628521780c048af14a148f373c84e687b26 (CL 668475)

Fixes #73542

Change-Id: I218851c5c0b62700281feb0b3f82b6b9b97b910d
Reviewed-on: https://go-review.googlesource.com/c/go/+/670055
Reviewed-by: Keith Randall <khr@google.com>
Auto-Submit: Keith Randall <khr@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

3 files changed, 16 insertions, 47 deletions

diff --git a/src/runtime/preempt.go b/src/runtime/preempt.go
index 364929f635..c41c355835 100644
--- a/src/runtime/preempt.go
+++ b/src/runtime/preempt.go
@@ -173,7 +173,6 @@ func suspendG(gp *g) suspendGState {
 			// _Gscan bit and thus own the stack.
 			gp.preemptStop = false
 			gp.preempt = false
-			gp.preemptRecent = true
 			gp.stackguard0 = gp.stack.lo + stackGuard
 
 			// The goroutine was already at a safe-point
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index f42c940b8e..05cf345baf 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -466,29 +466,22 @@ type g struct {
 	runnableTime  int64 // the amount of time spent runnable, cleared when running, only used when tracking
 	lockedm       muintptr
 	fipsIndicator uint8
-
-	// preemptRecent is set when a goroutine is preempted.  It is
-	// reset by code passing through the synchronous preemption
-	// path. It is used to avoid growing the stack when we were
-	// just preempting, see issue 35470.
-	preemptRecent bool
-
-	sig        uint32
-	writebuf   []byte
-	sigcode0   uintptr
-	sigcode1   uintptr
-	sigpc      uintptr
-	parentGoid uint64          // goid of goroutine that created this goroutine
-	gopc       uintptr         // pc of go statement that created this goroutine
-	ancestors  *[]ancestorInfo // ancestor information goroutine(s) that created this goroutine (only used if debug.tracebackancestors)
-	startpc    uintptr         // pc of goroutine function
-	racectx    uintptr
-	waiting    *sudog         // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
-	cgoCtxt    []uintptr      // cgo traceback context
-	labels     unsafe.Pointer // profiler labels
-	timer      *timer         // cached timer for time.Sleep
-	sleepWhen  int64          // when to sleep until
-	selectDone atomic.Uint32  // are we participating in a select and did someone win the race?
+	sig           uint32
+	writebuf      []byte
+	sigcode0      uintptr
+	sigcode1      uintptr
+	sigpc         uintptr
+	parentGoid    uint64          // goid of goroutine that created this goroutine
+	gopc          uintptr         // pc of go statement that created this goroutine
+	ancestors     *[]ancestorInfo // ancestor information goroutine(s) that created this goroutine (only used if debug.tracebackancestors)
+	startpc       uintptr         // pc of goroutine function
+	racectx       uintptr
+	waiting       *sudog         // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
+	cgoCtxt       []uintptr      // cgo traceback context
+	labels        unsafe.Pointer // profiler labels
+	timer         *timer         // cached timer for time.Sleep
+	sleepWhen     int64          // when to sleep until
+	selectDone    atomic.Uint32  // are we participating in a select and did someone win the race?
 
 	// goroutineProfiled indicates the status of this goroutine's stack for the
 	// current in-progress goroutine profile
diff --git a/src/runtime/stack.go b/src/runtime/stack.go
index 67a394cd12..2fedaa9421 100644
--- a/src/runtime/stack.go
+++ b/src/runtime/stack.go
@@ -1075,29 +1075,6 @@ func newstack() {
 		gopreempt_m(gp) // never return
 	}
 
-	if stackguard0 == gp.stack.lo+stackGuard && gp.preemptRecent {
-		// The case happens because of an interaction between synchronous
-		// and asynchronous preemption. First, we set the cooperative
-		// preemption signal (g.stackguard0 = stackPreempt), and as a
-		// result the function fails the stack check and enters its
-		// morestack path. If it gets suspended at that point, we might
-		// give up waiting for it and send an async preempt. That async
-		// preempt gets processed and clears the cooperative preemption
-		// signal (g.stackguard0 = g.stack.lo+stackGuard) and resumes
-		// the function. But even though the cooperative preemption
-		// signal is cleared, we're already on the morestack path and
-		// can't avoid calling morestack. See issue 35470.
-		//
-		// To avoid this problem, if we've been preempted recently,
-		// clear the "preempted recently" flag and resume the G.
-		// If we really did need more stack, the morestack check will
-		// immediately fail and we'll get back here to try again (with
-		// preemptRecent==false, so we don't take this case the
-		// second time).
-		gp.preemptRecent = false
-		gogo(&gp.sched) // never return
-	}
-
 	// Allocate a bigger segment and move the stack.
 	oldsize := gp.stack.hi - gp.stack.lo
 	newsize := oldsize * 2