runtime: remove go115ReduceLiveness and go115RestartSeq

Make them always true. Delete code that are only executed when
they are false.

Change-Id: I6194fa00de23486c2b0a0c9075fe3a09d9c52762
Reviewed-on: https://go-review.googlesource.com/c/go/+/264339
Trust: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Austin Clements <austin@google.com>

diff --git a/src/runtime/debugcall.go b/src/runtime/debugcall.go
index b5480c73aee7d609a2f58583a985457ab2eededb..efc68a767d4a7c40a65b97cdcbaffef922ef46e7 100644 (file)
--- a/src/runtime/debugcall.go
+++ b/src/runtime/debugcall.go
@@ -76,32 +76,14 @@ func debugCallCheck(pc uintptr) string {
                        return
                }
 
-               if !go115ReduceLiveness {
-                       // Look up PC's register map.
-                       pcdata := int32(-1)
-                       if pc != f.entry {
-                               pc--
-                               pcdata = pcdatavalue(f, _PCDATA_RegMapIndex, pc, nil)
-                       }
-                       if pcdata == -1 {
-                               pcdata = 0 // in prologue
-                       }
-                       stkmap := (*stackmap)(funcdata(f, _FUNCDATA_RegPointerMaps))
-                       if pcdata == _PCDATA_RegMapUnsafe || stkmap == nil {
-                               // Not at a safe point.
-                               ret = debugCallUnsafePoint
-                               return
-                       }
-               } else {
-                       // Check that this isn't an unsafe-point.
-                       if pc != f.entry {
-                               pc--
-                       }
-                       up := pcdatavalue(f, _PCDATA_UnsafePoint, pc, nil)
-                       if up != _PCDATA_UnsafePointSafe {
-                               // Not at a safe point.
-                               ret = debugCallUnsafePoint
-                       }
+               // Check that this isn't an unsafe-point.
+               if pc != f.entry {
+                       pc--
+               }
+               up := pcdatavalue(f, _PCDATA_UnsafePoint, pc, nil)
+               if up != _PCDATA_UnsafePointSafe {
+                       // Not at a safe point.
+                       ret = debugCallUnsafePoint
                }
        })
        return ret

diff --git a/src/runtime/funcdata.h b/src/runtime/funcdata.h
index cd76c0699258d19ba1efc724750ba3a9efcc4e9f..e9b6a7ed06e42e516da8794d4920ab19d2b12b34 100644 (file)
--- a/src/runtime/funcdata.h
+++ b/src/runtime/funcdata.h
@@ -8,13 +8,12 @@
 //
 // These must agree with symtab.go and ../cmd/internal/objabi/funcdata.go.
 
-#define PCDATA_RegMapIndex 0
+#define PCDATA_UnsafePoint 0
 #define PCDATA_StackMapIndex 1
 #define PCDATA_InlTreeIndex 2
 
 #define FUNCDATA_ArgsPointerMaps 0 /* garbage collector blocks */
 #define FUNCDATA_LocalsPointerMaps 1
-#define FUNCDATA_RegPointerMaps 2
 #define FUNCDATA_StackObjects 3
 #define FUNCDATA_InlTree 4
 #define FUNCDATA_OpenCodedDeferInfo 5 /* info for func with open-coded defers */

diff --git a/src/runtime/preempt.go b/src/runtime/preempt.go
index 17ef2c90d356430f104a6428b368675eed2676fd..372185266f7524e4a79f84d84aa94e926e2f5d62 100644 (file)
--- a/src/runtime/preempt.go
+++ b/src/runtime/preempt.go
@@ -58,11 +58,6 @@ import (
        "unsafe"
 )
 
-// Keep in sync with cmd/compile/internal/gc/plive.go:go115ReduceLiveness.
-const go115ReduceLiveness = true
-
-const go115RestartSeq = go115ReduceLiveness && true // enable restartable sequences
-
 type suspendGState struct {
        g *g
 
@@ -402,24 +397,12 @@ func isAsyncSafePoint(gp *g, pc, sp, lr uintptr) (bool, uintptr) {
                // use the LR for unwinding, which will be bad.
                return false, 0
        }
-       var up int32
-       var startpc uintptr
-       if !go115ReduceLiveness {
-               smi := pcdatavalue(f, _PCDATA_RegMapIndex, pc, nil)
-               if smi == _PCDATA_RegMapUnsafe {
-                       // Unsafe-point marked by compiler. This includes
-                       // atomic sequences (e.g., write barrier) and nosplit
-                       // functions (except at calls).
-                       return false, 0
-               }
-       } else {
-               up, startpc = pcdatavalue2(f, _PCDATA_UnsafePoint, pc)
-               if up != _PCDATA_UnsafePointSafe {
-                       // Unsafe-point marked by compiler. This includes
-                       // atomic sequences (e.g., write barrier) and nosplit
-                       // functions (except at calls).
-                       return false, 0
-               }
+       up, startpc := pcdatavalue2(f, _PCDATA_UnsafePoint, pc)
+       if up != _PCDATA_UnsafePointSafe {
+               // Unsafe-point marked by compiler. This includes
+               // atomic sequences (e.g., write barrier) and nosplit
+               // functions (except at calls).
+               return false, 0
        }
        if fd := funcdata(f, _FUNCDATA_LocalsPointerMaps); fd == nil || fd == unsafe.Pointer(&no_pointers_stackmap) {
                // This is assembly code. Don't assume it's
@@ -455,25 +438,17 @@ func isAsyncSafePoint(gp *g, pc, sp, lr uintptr) (bool, uintptr) {
                // in incrementally.
                return false, 0
        }
-       if go115RestartSeq {
-               switch up {
-               case _PCDATA_Restart1, _PCDATA_Restart2:
-                       // Restartable instruction sequence. Back off PC to
-                       // the start PC.
-                       if startpc == 0 || startpc > pc || pc-startpc > 20 {
-                               throw("bad restart PC")
-                       }
-                       return true, startpc
-               case _PCDATA_RestartAtEntry:
-                       // Restart from the function entry at resumption.
-                       return true, f.entry
-               }
-       } else {
-               switch up {
-               case _PCDATA_Restart1, _PCDATA_Restart2, _PCDATA_RestartAtEntry:
-                       // go115RestartSeq is not enabled. Treat it as unsafe point.
-                       return false, 0
+       switch up {
+       case _PCDATA_Restart1, _PCDATA_Restart2:
+               // Restartable instruction sequence. Back off PC to
+               // the start PC.
+               if startpc == 0 || startpc > pc || pc-startpc > 20 {
+                       throw("bad restart PC")
                }
+               return true, startpc
+       case _PCDATA_RestartAtEntry:
+               // Restart from the function entry at resumption.
+               return true, f.entry
        }
        return true, pc
 }

diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index 932fba3de05249835ca53308c12a8313b80d4e3e..a4b4344ea7cde88f633bf361108f557da94422d6 100644 (file)
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -268,14 +268,12 @@ func (f *Func) funcInfo() funcInfo {
 //
 // See funcdata.h and ../cmd/internal/objabi/funcdata.go.
 const (
-       _PCDATA_RegMapIndex   = 0 // if !go115ReduceLiveness
-       _PCDATA_UnsafePoint   = 0 // if go115ReduceLiveness
+       _PCDATA_UnsafePoint   = 0
        _PCDATA_StackMapIndex = 1
        _PCDATA_InlTreeIndex  = 2
 
        _FUNCDATA_ArgsPointerMaps    = 0
        _FUNCDATA_LocalsPointerMaps  = 1
-       _FUNCDATA_RegPointerMaps     = 2 // if !go115ReduceLiveness
        _FUNCDATA_StackObjects       = 3
        _FUNCDATA_InlTree            = 4
        _FUNCDATA_OpenCodedDeferInfo = 5
@@ -284,9 +282,6 @@ const (
 )
 
 const (
-       // Only if !go115ReduceLiveness.
-       _PCDATA_RegMapUnsafe = _PCDATA_UnsafePointUnsafe // Unsafe for async preemption
-
        // PCDATA_UnsafePoint values.
        _PCDATA_UnsafePointSafe   = -1 // Safe for async preemption
        _PCDATA_UnsafePointUnsafe = -2 // Unsafe for async preemption