cmd/compile: use OffPtr when possible

OffPtr allocates less and is easier to optimize.

With this change, the OffPtr collapsing opt
rule matches increase from 160k to 263k,
and the Load-after-Store opt rule matches
increase from 217 to 853.

Change-Id: I763426a3196900f22a367f7f6d8e8047b279653d
Reviewed-on: https://go-review.googlesource.com/20273
Run-TryBot: Todd Neal <todd@tneal.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Todd Neal <todd@tneal.org>
Reviewed-by: Keith Randall <khr@golang.org>

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index d4f06f282489f9c3240039956325537fb5ba51cb..df5e969c135a34f2040504b1bc82148074a41ec4 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -1869,7 +1869,7 @@ func (s *state) expr(n *Node) *ssa.Value {
        case ODOTPTR:
                p := s.expr(n.Left)
                s.nilCheck(p)
-               p = s.newValue2(ssa.OpAddPtr, p.Type, p, s.constInt(Types[TINT], n.Xoffset))
+               p = s.newValue1I(ssa.OpOffPtr, p.Type, n.Xoffset, p)
                return s.newValue2(ssa.OpLoad, n.Type, p, s.mem())
 
        case OINDEX:
@@ -1884,7 +1884,11 @@ func (s *state) expr(n *Node) *ssa.Value {
                        }
                        ptrtyp := Ptrto(Types[TUINT8])
                        ptr := s.newValue1(ssa.OpStringPtr, ptrtyp, a)
-                       ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i)
+                       if Isconst(n.Right, CTINT) {
+                               ptr = s.newValue1I(ssa.OpOffPtr, ptrtyp, n.Right.Int(), ptr)
+                       } else {
+                               ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i)
+                       }
                        return s.newValue2(ssa.OpLoad, Types[TUINT8], ptr, s.mem())
                case n.Left.Type.IsSlice():
                        p := s.addr(n, false)
@@ -2526,17 +2530,16 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value {
                return p
        case ODOT:
                p := s.addr(n.Left, bounded)
-               return s.newValue2(ssa.OpAddPtr, t, p, s.constInt(Types[TINT], n.Xoffset))
+               return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset, p)
        case ODOTPTR:
                p := s.expr(n.Left)
                if !bounded {
                        s.nilCheck(p)
                }
-               return s.newValue2(ssa.OpAddPtr, t, p, s.constInt(Types[TINT], n.Xoffset))
+               return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset, p)
        case OCLOSUREVAR:
-               return s.newValue2(ssa.OpAddPtr, t,
-                       s.entryNewValue0(ssa.OpGetClosurePtr, Ptrto(Types[TUINT8])),
-                       s.constInt(Types[TINT], n.Xoffset))
+               return s.newValue1I(ssa.OpOffPtr, t, n.Xoffset,
+                       s.entryNewValue0(ssa.OpGetClosurePtr, Ptrto(Types[TUINT8])))
        case OPARAM:
                p := n.Left
                if p.Op != ONAME || !(p.Class == PPARAM|PHEAP || p.Class == PPARAMOUT|PHEAP) {