cmd/compile: add convnop helper function

Like the conv helper function but for creating OCONVNOP nodes
instead of OCONV nodes.

passes toolstash -cmp

Change-Id: Ib93ffe66590ebaa2b4fa552c81f1a2902e789d8e
Reviewed-on: https://go-review.googlesource.com/112597
Run-TryBot: Martin Möhrmann <moehrmann@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index ce575a64180e3ed71c05b271349f2294686919a1..834cdc41eb6e5e16abbb0a8037c1c84bcb18dd8d 100644 (file)
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -382,10 +382,7 @@ func walkclosure(clo *Node, init *Nodes) *Node {
        clos.List.Set(append([]*Node{nod(OCFUNC, xfunc.Func.Nname, nil)}, clo.Func.Enter.Slice()...))
 
        // Force type conversion from *struct to the func type.
-       clos = nod(OCONVNOP, clos, nil)
-       clos.Type = clo.Type
-
-       clos = typecheck(clos, Erv)
+       clos = convnop(clos, clo.Type)
 
        // typecheck will insert a PTRLIT node under CONVNOP,
        // tag it with escape analysis result.
@@ -511,10 +508,7 @@ func walkpartialcall(n *Node, init *Nodes) *Node {
        clos.List.Append(n.Left)
 
        // Force type conversion from *struct to the func type.
-       clos = nod(OCONVNOP, clos, nil)
-       clos.Type = n.Type
-
-       clos = typecheck(clos, Erv)
+       clos = convnop(clos, n.Type)
 
        // typecheck will insert a PTRLIT node under CONVNOP,
        // tag it with escape analysis result.

diff --git a/src/cmd/compile/internal/gc/range.go b/src/cmd/compile/internal/gc/range.go
index 591bd06368770706fc3ba24af200f9dc45709a8f..13f45e164dfcbec0a67fbb0f83296db43a4cb061 100644 (file)
--- a/src/cmd/compile/internal/gc/range.go
+++ b/src/cmd/compile/internal/gc/range.go
@@ -580,8 +580,7 @@ func arrayClear(n, v1, v2, a *Node) bool {
        tmp := nod(OINDEX, a, nodintconst(0))
        tmp.SetBounded(true)
        tmp = nod(OADDR, tmp, nil)
-       tmp = nod(OCONVNOP, tmp, nil)
-       tmp.Type = types.Types[TUNSAFEPTR]
+       tmp = convnop(tmp, types.Types[TUNSAFEPTR])
        n.Nbody.Append(nod(OAS, hp, tmp))
 
        // hn = len(a) * sizeof(elem(a))

diff --git a/src/cmd/compile/internal/gc/select.go b/src/cmd/compile/internal/gc/select.go
index 4445edbe920962e4896c5b956694984b7b39510d..c7f39088880f908479e7204b61bba74e681ef4ad 100644 (file)
--- a/src/cmd/compile/internal/gc/select.go
+++ b/src/cmd/compile/internal/gc/select.go
@@ -316,13 +316,11 @@ func walkselectcases(cases *Nodes) []*Node {
 
                setField("kind", nodintconst(kind))
                if c != nil {
-                       c = nod(OCONVNOP, c, nil)
-                       c.Type = types.Types[TUNSAFEPTR]
+                       c = convnop(c, types.Types[TUNSAFEPTR])
                        setField("c", c)
                }
                if elem != nil {
-                       elem = nod(OCONVNOP, elem, nil)
-                       elem.Type = types.Types[TUNSAFEPTR]
+                       elem = convnop(elem, types.Types[TUNSAFEPTR])
                        setField("elem", elem)
                }
 
@@ -375,10 +373,9 @@ func walkselectcases(cases *Nodes) []*Node {
 
 // bytePtrToIndex returns a Node representing "(*byte)(&n[i])".
 func bytePtrToIndex(n *Node, i int64) *Node {
-       s := nod(OCONVNOP, nod(OADDR, nod(OINDEX, n, nodintconst(i)), nil), nil)
-       s.Type = types.NewPtr(types.Types[TUINT8])
-       s = typecheck(s, Erv)
-       return s
+       s := nod(OADDR, nod(OINDEX, n, nodintconst(i)), nil)
+       t := types.NewPtr(types.Types[TUINT8])
+       return convnop(s, t)
 }
 
 var scase *types.Type

diff --git a/src/cmd/compile/internal/gc/subr.go b/src/cmd/compile/internal/gc/subr.go
index 0af0ff82c4e934be3e27ab03ef9f7403dd97dfb6..61a3b2385d3a698213baf8c27b3adc504aeb7267 100644 (file)
--- a/src/cmd/compile/internal/gc/subr.go
+++ b/src/cmd/compile/internal/gc/subr.go
@@ -1674,8 +1674,7 @@ func genwrapper(rcvr *types.Type, method *types.Field, newnam *types.Sym) {
                if !dotlist[0].field.Type.IsPtr() {
                        dot = nod(OADDR, dot, nil)
                }
-               as := nod(OAS, nthis, nod(OCONVNOP, dot, nil))
-               as.Right.Type = rcvr
+               as := nod(OAS, nthis, convnop(dot, rcvr))
                fn.Nbody.Append(as)
                fn.Nbody.Append(nodSym(ORETJMP, nil, methodSym(methodrcvr, method.Sym)))
        } else {

diff --git a/src/cmd/compile/internal/gc/walk.go b/src/cmd/compile/internal/gc/walk.go
index f75e729eb5508100f5a568bcdef83b9c248a2157..00c3cf287254c0b3cdf43c9b7cd90afebc598018 100644 (file)
--- a/src/cmd/compile/internal/gc/walk.go
+++ b/src/cmd/compile/internal/gc/walk.go
@@ -1506,9 +1506,7 @@ opswitch:
                                a = typecheck(a, Etop)
                                a = walkexpr(a, init)
                                init.Append(a)
-                               n = nod(OCONVNOP, h, nil)
-                               n.Type = t
-                               n = typecheck(n, Erv)
+                               n = convnop(h, t)
                        } else {
                                // Call runtime.makehmap to allocate an
                                // hmap on the heap and initialize hmap's hash0 field.
@@ -2029,8 +2027,7 @@ func ascompatte(call *Node, isddd bool, lhs *types.Type, rhs []*Node, fp int, in
                // optimization - can do block copy
                if eqtypenoname(rhs[0].Type, lhs) {
                        nl := nodarg(lhs, fp)
-                       nr := nod(OCONVNOP, rhs[0], nil)
-                       nr.Type = nl.Type
+                       nr := convnop(rhs[0], nl.Type)
                        n := convas(nod(OAS, nl, nr), init)
                        n.SetTypecheck(1)
                        return []*Node{n}
@@ -2748,6 +2745,15 @@ func conv(n *Node, t *types.Type) *Node {
        return n
 }
 
+// convnop converts node n to type t using the OCONVNOP op
+// and typechecks the result with Erv.
+func convnop(n *Node, t *types.Type) *Node {
+       n = nod(OCONVNOP, n, nil)
+       n.Type = t
+       n = typecheck(n, Erv)
+       return n
+}
+
 // byteindex converts n, which is byte-sized, to a uint8.
 // We cannot use conv, because we allow converting bool to uint8 here,
 // which is forbidden in user code.
@@ -3157,8 +3163,7 @@ func extendslice(n *Node, init *Nodes) *Node {
        hp := nod(OINDEX, s, nod(OLEN, l1, nil))
        hp.SetBounded(true)
        hp = nod(OADDR, hp, nil)
-       hp = nod(OCONVNOP, hp, nil)
-       hp.Type = types.Types[TUNSAFEPTR]
+       hp = convnop(hp, types.Types[TUNSAFEPTR])
 
        // hn := l2 * sizeof(elem(s))
        hn := nod(OMUL, l2, nodintconst(elemtype.Width))