cmd/compile: remove zeroing after newobject

The Zero op right after newobject has been removed. But this rule
does not cover Store of constant zero (for SSA-able types). Add
rules to cover Store op as well.

Updates #19027.

Change-Id: I5d2b62eeca0aa9ce8dc7205b264b779de01c660b
Reviewed-on: https://go-review.googlesource.com/36836
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

diff --git a/src/cmd/compile/internal/ssa/gen/generic.rules b/src/cmd/compile/internal/ssa/gen/generic.rules
index 4adbc9e45f0962448ae61c4008dbc149f85446ba..c7d1743d5b38807c454515ff0e4e3dd853712caa 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/generic.rules
+++ b/src/cmd/compile/internal/ssa/gen/generic.rules
@@ -1390,6 +1390,18 @@
        && isSameSym(mem.Aux, "runtime.newobject")
        && c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value
        -> mem
+(Store (Load (OffPtr [c] (SP)) mem) x mem)
+       && isConstZero(x)
+       && mem.Op == OpStaticCall
+       && isSameSym(mem.Aux, "runtime.newobject")
+       && c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value
+       -> mem
+(Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
+       && isConstZero(x)
+       && mem.Op == OpStaticCall
+       && isSameSym(mem.Aux, "runtime.newobject")
+       && c == config.ctxt.FixedFrameSize() + config.RegSize // offset of return value
+       -> mem
 // nil checks just need to rewrite to something useless.
 // they will be deadcode eliminated soon afterwards.
 (NilCheck (Load (OffPtr [c] (SP)) mem) mem)

diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index f7d256df1625ea622cc7484e122ce3425030ae43..b0a16296cd78d5236769b21e8f55c7630f862685 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -541,3 +541,13 @@ func experiment(f *Func) bool {
        }
        return r
 }
+
+func isConstZero(v *Value) bool {
+       switch v.Op {
+       case OpConstNil:
+               return true
+       case OpConst64, OpConst32, OpConst16, OpConst8, OpConstBool, OpConst32F, OpConst64F:
+               return v.AuxInt == 0
+       }
+       return false
+}

diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 0709eb89bbf420bd9150fdbc48d31f726ca3f406..c14a3e000c1733e33367ee351ff35cc85c4512d7 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -14668,6 +14668,70 @@ func rewriteValuegeneric_OpStore(v *Value, config *Config) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (Store (Load (OffPtr [c] (SP)) mem) x mem)
+       // cond: isConstZero(x)         && mem.Op == OpStaticCall       && isSameSym(mem.Aux, "runtime.newobject")      && c == config.ctxt.FixedFrameSize() + config.RegSize
+       // result: mem
+       for {
+               v_0 := v.Args[0]
+               if v_0.Op != OpLoad {
+                       break
+               }
+               v_0_0 := v_0.Args[0]
+               if v_0_0.Op != OpOffPtr {
+                       break
+               }
+               c := v_0_0.AuxInt
+               v_0_0_0 := v_0_0.Args[0]
+               if v_0_0_0.Op != OpSP {
+                       break
+               }
+               mem := v_0.Args[1]
+               x := v.Args[1]
+               if mem != v.Args[2] {
+                       break
+               }
+               if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
+                       break
+               }
+               v.reset(OpCopy)
+               v.Type = mem.Type
+               v.AddArg(mem)
+               return true
+       }
+       // match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
+       // cond: isConstZero(x)         && mem.Op == OpStaticCall       && isSameSym(mem.Aux, "runtime.newobject")      && c == config.ctxt.FixedFrameSize() + config.RegSize
+       // result: mem
+       for {
+               v_0 := v.Args[0]
+               if v_0.Op != OpOffPtr {
+                       break
+               }
+               v_0_0 := v_0.Args[0]
+               if v_0_0.Op != OpLoad {
+                       break
+               }
+               v_0_0_0 := v_0_0.Args[0]
+               if v_0_0_0.Op != OpOffPtr {
+                       break
+               }
+               c := v_0_0_0.AuxInt
+               v_0_0_0_0 := v_0_0_0.Args[0]
+               if v_0_0_0_0.Op != OpSP {
+                       break
+               }
+               mem := v_0_0.Args[1]
+               x := v.Args[1]
+               if mem != v.Args[2] {
+                       break
+               }
+               if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
+                       break
+               }
+               v.reset(OpCopy)
+               v.Type = mem.Type
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool {