cmd/compile/internal/gc: remove more backend Sym uses

Removes all external uses of Linksym and Pkglookup, which are the only
two exported functions that return Syms.

Also add Duffcopy and Duffzero since they're used often enough across
SSA backends.

Passes toolstash -cmp.

Change-Id: I8d3fd048ad5cd676fc46378f09a917569ffc9b2c
Reviewed-on: https://go-review.googlesource.com/36418
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

diff --git a/src/cmd/compile/internal/amd64/ggen.go b/src/cmd/compile/internal/amd64/ggen.go
index c137b52d8042fa49f5a6f850b4f427809c42784a..a7b805eac69d2cdf91dfc28bbe0e99fed89bde11 100644 (file)
--- a/src/cmd/compile/internal/amd64/ggen.go
+++ b/src/cmd/compile/internal/amd64/ggen.go
@@ -146,7 +146,7 @@ func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, ax *uint32, x0 *uin
                }
                p = gc.Appendpp(p, leaptr, obj.TYPE_MEM, x86.REG_SP, frame+lo+dzDI(cnt), obj.TYPE_REG, x86.REG_DI, 0)
                p = gc.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, dzOff(cnt))
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+               p.To.Sym = gc.Duffzero
 
                if cnt%16 != 0 {
                        p = gc.Appendpp(p, x86.AMOVUPS, obj.TYPE_REG, x86.REG_X0, 0, obj.TYPE_MEM, x86.REG_DI, -int64(8))

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 4b0e3954954d627eb9da2af59f6a670244c94b40..4a95d02960d5fc4b842508ed194deeb3f7c01b85 100644 (file)
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -658,7 +658,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                }
                p = gc.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_ADDR
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+               p.To.Sym = gc.Duffzero
                p.To.Offset = off
        case ssa.OpAMD64MOVOconst:
                if v.AuxInt != 0 {
@@ -669,7 +669,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
        case ssa.OpAMD64DUFFCOPY:
                p := gc.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_ADDR
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffcopy", gc.Runtimepkg))
+               p.To.Sym = gc.Duffcopy
                p.To.Offset = v.AuxInt
 
        case ssa.OpCopy, ssa.OpAMD64MOVQconvert, ssa.OpAMD64MOVLconvert: // TODO: use MOVQreg for reg->reg copies instead of OpCopy?

diff --git a/src/cmd/compile/internal/arm/ggen.go b/src/cmd/compile/internal/arm/ggen.go
index 6dce0a4e80678e0b9b6ea2de5847bea25c9ed045..7af3cd744366fe7ad8b959bc91ebed9d7a084213 100644 (file)
--- a/src/cmd/compile/internal/arm/ggen.go
+++ b/src/cmd/compile/internal/arm/ggen.go
@@ -74,7 +74,8 @@ func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, r0 *uint32) *obj.Pr
                p = gc.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, 4+frame+lo, obj.TYPE_REG, arm.REG_R1, 0)
                p.Reg = arm.REGSP
                p = gc.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
-               gc.Naddr(&p.To, gc.Sysfunc("duffzero"))
+               p.To.Name = obj.NAME_EXTERN
+               p.To.Sym = gc.Duffzero
                p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
        } else {
                p = gc.Appendpp(p, arm.AADD, obj.TYPE_CONST, 0, 4+frame+lo, obj.TYPE_REG, arm.REG_R1, 0)

diff --git a/src/cmd/compile/internal/arm/ssa.go b/src/cmd/compile/internal/arm/ssa.go
index 63488f71163766c7117a6c484cb69089810aed3c..c595ffab605466613cbcb063ece0d757a403faa1 100644 (file)
--- a/src/cmd/compile/internal/arm/ssa.go
+++ b/src/cmd/compile/internal/arm/ssa.go
@@ -689,13 +689,13 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := gc.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+               p.To.Sym = gc.Duffzero
                p.To.Offset = v.AuxInt
        case ssa.OpARMDUFFCOPY:
                p := gc.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffcopy", gc.Runtimepkg))
+               p.To.Sym = gc.Duffcopy
                p.To.Offset = v.AuxInt
        case ssa.OpARMLoweredNilCheck:
                // Issue a load which will fault if arg is nil.

diff --git a/src/cmd/compile/internal/arm64/ggen.go b/src/cmd/compile/internal/arm64/ggen.go
index 16813b642ab4bcb5922ec529f03e39d10c0c29d4..e9418df79e15f38227ca8df6df77074341d7b132 100644 (file)
--- a/src/cmd/compile/internal/arm64/ggen.go
+++ b/src/cmd/compile/internal/arm64/ggen.go
@@ -81,7 +81,8 @@ func zerorange(p *obj.Prog, frame int64, lo int64, hi int64) *obj.Prog {
                p = gc.Appendpp(p, arm64.AADD, obj.TYPE_CONST, 0, 8+frame+lo-8, obj.TYPE_REG, arm64.REGRT1, 0)
                p.Reg = arm64.REGRT1
                p = gc.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
-               gc.Naddr(&p.To, gc.Sysfunc("duffzero"))
+               p.To.Name = obj.NAME_EXTERN
+               p.To.Sym = gc.Duffzero
                p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
        } else {
                p = gc.Appendpp(p, arm64.AMOVD, obj.TYPE_CONST, 0, 8+frame+lo-8, obj.TYPE_REG, arm64.REGTMP, 0)

diff --git a/src/cmd/compile/internal/arm64/ssa.go b/src/cmd/compile/internal/arm64/ssa.go
index a8101ae844a82cf425ac97f70bf6a87c9f06b62b..63490e8f1e80b230d533337e757d507a75a74b90 100644 (file)
--- a/src/cmd/compile/internal/arm64/ssa.go
+++ b/src/cmd/compile/internal/arm64/ssa.go
@@ -577,7 +577,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p = gc.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+               p.To.Sym = gc.Duffzero
                p.To.Offset = v.AuxInt
        case ssa.OpARM64LoweredZero:
                // MOVD.P       ZR, 8(R16)
@@ -602,7 +602,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p := gc.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffcopy", gc.Runtimepkg))
+               p.To.Sym = gc.Duffcopy
                p.To.Offset = v.AuxInt
        case ssa.OpARM64LoweredMove:
                // MOVD.P       8(R16), Rtmp

diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index 49ccc417607f22bc9b9c0121b7fa922e5c706d6e..cc202e741a22d4825687b8d8c1f536d00831c51c 100644 (file)
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -6,12 +6,13 @@
 
 package gc
 
-import "fmt"
+import (
+       "cmd/internal/obj"
+       "fmt"
+)
 
-func Sysfunc(name string) *Node {
-       n := newname(Pkglookup(name, Runtimepkg))
-       n.Class = PFUNC
-       return n
+func Sysfunc(name string) *obj.LSym {
+       return Linksym(Pkglookup(name, Runtimepkg))
 }
 
 // addrescapes tags node n as having had its address taken

diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 0d5e30d002d39b72ada7bda20459e5a5cbe11380..c6fcfd73470b189d63a30cf089f45911ef848203 100644 (file)
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -370,6 +370,8 @@ var (
        Newproc,
        Deferproc,
        Deferreturn,
+       Duffcopy,
+       Duffzero,
        panicindex,
        panicslice,
        panicdivide,

diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index 1796fb3df197739d3dfa432682c149a687a371e0..64f61b4352bd0df92d5ec2425bfe8127cf533953 100644 (file)
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -297,19 +297,21 @@ func (s *ssaExport) AllocFrame(f *ssa.Func) {
 
 func compile(fn *Node) {
        if Newproc == nil {
-               Newproc = Linksym(Sysfunc("newproc").Sym)
-               Deferproc = Linksym(Sysfunc("deferproc").Sym)
-               Deferreturn = Linksym(Sysfunc("deferreturn").Sym)
-               panicindex = Linksym(Sysfunc("panicindex").Sym)
-               panicslice = Linksym(Sysfunc("panicslice").Sym)
-               panicdivide = Linksym(Sysfunc("panicdivide").Sym)
-               growslice = Linksym(Sysfunc("growslice").Sym)
-               panicdottype = Linksym(Sysfunc("panicdottype").Sym)
-               panicnildottype = Linksym(Sysfunc("panicnildottype").Sym)
-               assertE2I = Linksym(Sysfunc("assertE2I").Sym)
-               assertE2I2 = Linksym(Sysfunc("assertE2I2").Sym)
-               assertI2I = Linksym(Sysfunc("assertI2I").Sym)
-               assertI2I2 = Linksym(Sysfunc("assertI2I2").Sym)
+               Newproc = Sysfunc("newproc")
+               Deferproc = Sysfunc("deferproc")
+               Deferreturn = Sysfunc("deferreturn")
+               Duffcopy = Sysfunc("duffcopy")
+               Duffzero = Sysfunc("duffzero")
+               panicindex = Sysfunc("panicindex")
+               panicslice = Sysfunc("panicslice")
+               panicdivide = Sysfunc("panicdivide")
+               growslice = Sysfunc("growslice")
+               panicdottype = Sysfunc("panicdottype")
+               panicnildottype = Sysfunc("panicnildottype")
+               assertE2I = Sysfunc("assertE2I")
+               assertE2I2 = Sysfunc("assertE2I2")
+               assertI2I = Sysfunc("assertI2I")
+               assertI2I2 = Sysfunc("assertI2I2")
        }
 
        defer func(lno src.XPos) {

diff --git a/src/cmd/compile/internal/mips64/ggen.go b/src/cmd/compile/internal/mips64/ggen.go
index 2af4a8b1ce620432605338981c9c92956ab89059..1bb47ff11298a718c9974020094e1b88222f786e 100644 (file)
--- a/src/cmd/compile/internal/mips64/ggen.go
+++ b/src/cmd/compile/internal/mips64/ggen.go
@@ -71,7 +71,8 @@ func zerorange(p *obj.Prog, frame int64, lo int64, hi int64) *obj.Prog {
                p = gc.Appendpp(p, mips.AADDV, obj.TYPE_CONST, 0, 8+frame+lo-8, obj.TYPE_REG, mips.REGRT1, 0)
                p.Reg = mips.REGSP
                p = gc.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
-               gc.Naddr(&p.To, gc.Sysfunc("duffzero"))
+               p.To.Name = obj.NAME_EXTERN
+               p.To.Sym = gc.Duffzero
                p.To.Offset = 8 * (128 - cnt/int64(gc.Widthptr))
        } else {
                //      ADDV    $(8+frame+lo-8), SP, r1

diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go
index 067f4c00f1eb618ed21e3fefcdd1ef4a39d662b2..e67be062fbc2ecfe0c697df65f52f7d12d0de829 100644 (file)
--- a/src/cmd/compile/internal/mips64/ssa.go
+++ b/src/cmd/compile/internal/mips64/ssa.go
@@ -387,7 +387,7 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p = gc.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_MEM
                p.To.Name = obj.NAME_EXTERN
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+               p.To.Sym = gc.Duffzero
                p.To.Offset = v.AuxInt
        case ssa.OpMIPS64LoweredZero:
                // SUBV $8, R1

diff --git a/src/cmd/compile/internal/ppc64/ggen.go b/src/cmd/compile/internal/ppc64/ggen.go
index b3ce96856721949f14e25151ba3631654c5000ff..8064e4d9aa149e0d2479e00d3fae24dc0c670b07 100644 (file)
--- a/src/cmd/compile/internal/ppc64/ggen.go
+++ b/src/cmd/compile/internal/ppc64/ggen.go
@@ -71,7 +71,8 @@ func zerorange(p *obj.Prog, frame int64, lo int64, hi int64) *obj.Prog {
                p = gc.Appendpp(p, ppc64.AADD, obj.TYPE_CONST, 0, gc.Ctxt.FixedFrameSize()+frame+lo-8, obj.TYPE_REG, ppc64.REGRT1, 0)
                p.Reg = ppc64.REGSP
                p = gc.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_MEM, 0, 0)
-               gc.Naddr(&p.To, gc.Sysfunc("duffzero"))
+               p.To.Name = obj.NAME_EXTERN
+               p.To.Sym = gc.Duffzero
                p.To.Offset = 4 * (128 - cnt/int64(gc.Widthptr))
        } else {
                p = gc.Appendpp(p, ppc64.AMOVD, obj.TYPE_CONST, 0, gc.Ctxt.FixedFrameSize()+frame+lo-8, obj.TYPE_REG, ppc64.REGTMP, 0)

diff --git a/src/cmd/compile/internal/x86/387.go b/src/cmd/compile/internal/x86/387.go
index 248fec68cebbe27b6bd17ece6395a2bad0601964..ea62ce31ff7a4c7d5878446120a5c9e00b466271 100644 (file)
--- a/src/cmd/compile/internal/x86/387.go
+++ b/src/cmd/compile/internal/x86/387.go
@@ -124,7 +124,7 @@ func ssaGenValue387(s *gc.SSAGenState, v *ssa.Value) bool {
                        p = gc.Prog(x86.AFLDCW)
                        p.From.Type = obj.TYPE_MEM
                        p.From.Name = obj.NAME_EXTERN
-                       p.From.Sym = gc.Linksym(gc.Pkglookup("controlWord32", gc.Runtimepkg))
+                       p.From.Sym = gc.Sysfunc("controlWord32")
                }
 
                var op obj.As
@@ -221,7 +221,7 @@ func ssaGenValue387(s *gc.SSAGenState, v *ssa.Value) bool {
                p = gc.Prog(x86.AFLDCW)
                p.From.Type = obj.TYPE_MEM
                p.From.Name = obj.NAME_EXTERN
-               p.From.Sym = gc.Linksym(gc.Pkglookup("controlWord64trunc", gc.Runtimepkg))
+               p.From.Sym = gc.Sysfunc("controlWord64trunc")
 
                // Now do the conversion.
                p = gc.Prog(x86.AFMOVLP)

diff --git a/src/cmd/compile/internal/x86/ggen.go b/src/cmd/compile/internal/x86/ggen.go
index 25769b4de031ea87bc0f3fe220f952fc999d64aa..7f844531a725e722d195f621157a438f858cf4b3 100644 (file)
--- a/src/cmd/compile/internal/x86/ggen.go
+++ b/src/cmd/compile/internal/x86/ggen.go
@@ -73,7 +73,7 @@ func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, ax *uint32) *obj.Pr
        } else if !gc.Nacl && cnt <= int64(128*gc.Widthreg) {
                p = gc.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, frame+lo, obj.TYPE_REG, x86.REG_DI, 0)
                p = gc.Appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(gc.Widthreg)))
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+               p.To.Sym = gc.Duffzero
        } else {
                p = gc.Appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, x86.REG_CX, 0)
                p = gc.Appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, frame+lo, obj.TYPE_REG, x86.REG_DI, 0)

diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index 65646ad3b5a9bf1b19f92a96e706aa09a51bdd10..1f4b7bea079b7e6d1e8c58ec0fbb03c4819ac1dc 100644 (file)
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -587,12 +587,12 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
        case ssa.Op386DUFFZERO:
                p := gc.Prog(obj.ADUFFZERO)
                p.To.Type = obj.TYPE_ADDR
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
+               p.To.Sym = gc.Duffzero
                p.To.Offset = v.AuxInt
        case ssa.Op386DUFFCOPY:
                p := gc.Prog(obj.ADUFFCOPY)
                p.To.Type = obj.TYPE_ADDR
-               p.To.Sym = gc.Linksym(gc.Pkglookup("duffcopy", gc.Runtimepkg))
+               p.To.Sym = gc.Duffcopy
                p.To.Offset = v.AuxInt
 
        case ssa.OpCopy, ssa.Op386MOVLconvert: // TODO: use MOVLreg for reg->reg copies instead of OpCopy?