cmd/compile: bubble out some Linksym calls

Change a few functions so that instead of
accepting a *types.Sym and calling Linksym
themselves, they accept an *obj.LSym.
Adapt the callsites.

Passes toolstash-check.

Change-Id: Ic5d3f306f2fdd3913281215a1f54d893a966bb1f
Reviewed-on: https://go-review.googlesource.com/41404
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index aff80f382a7c46145ae0c390b15be6656c539c7d..5809858ef1a45def6aa41103ae48762c7bdec65a 100644 (file)
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -507,7 +507,7 @@ func isExportedField(ft *types.Field) (bool, *types.Pkg) {
 }
 
 // dnameField dumps a reflect.name for a struct field.
-func dnameField(s *types.Sym, ot int, spkg *types.Pkg, ft *types.Field) int {
+func dnameField(lsym *obj.LSym, ot int, spkg *types.Pkg, ft *types.Field) int {
        var name string
        if ft.Sym != nil {
                name = ft.Sym.Name
@@ -517,7 +517,7 @@ func dnameField(s *types.Sym, ot int, spkg *types.Pkg, ft *types.Field) int {
                fpkg = nil
        }
        nsym := dname(name, ft.Note, fpkg, isExported)
-       return dsymptr(s.Linksym(), ot, nsym, 0)
+       return dsymptr(lsym, ot, nsym, 0)
 }
 
 // dnameData writes the contents of a reflect.name into s at offset ot.
@@ -599,7 +599,7 @@ func dname(name, tag string, pkg *types.Pkg, exported bool) *obj.LSym {
 // dextratype dumps the fields of a runtime.uncommontype.
 // dataAdd is the offset in bytes after the header where the
 // backing array of the []method field is written (by dextratypeData).
-func dextratype(s *types.Sym, ot int, t *types.Type, dataAdd int) int {
+func dextratype(lsym *obj.LSym, ot int, t *types.Type, dataAdd int) int {
        m := methods(t)
        if t.Sym == nil && len(m) == 0 {
                return ot
@@ -613,7 +613,7 @@ func dextratype(s *types.Sym, ot int, t *types.Type, dataAdd int) int {
                dtypesym(a.type_)
        }
 
-       ot = dgopkgpathOff(s.Linksym(), ot, typePkg(t))
+       ot = dgopkgpathOff(lsym, ot, typePkg(t))
 
        dataAdd += uncommonSize(t)
        mcount := len(m)
@@ -624,10 +624,10 @@ func dextratype(s *types.Sym, ot int, t *types.Type, dataAdd int) int {
                Fatalf("methods are too far away on %v: %d", t, dataAdd)
        }
 
-       ot = duint16(s.Linksym(), ot, uint16(mcount))
-       ot = duint16(s.Linksym(), ot, 0)
-       ot = duint32(s.Linksym(), ot, uint32(dataAdd))
-       ot = duint32(s.Linksym(), ot, 0)
+       ot = duint16(lsym, ot, uint16(mcount))
+       ot = duint16(lsym, ot, 0)
+       ot = duint32(lsym, ot, uint32(dataAdd))
+       ot = duint32(lsym, ot, 0)
        return ot
 }
 
@@ -777,7 +777,7 @@ var (
 )
 
 // dcommontype dumps the contents of a reflect.rtype (runtime._type).
-func dcommontype(s *types.Sym, ot int, t *types.Type) int {
+func dcommontype(lsym *obj.LSym, ot int, t *types.Type) int {
        if ot != 0 {
                Fatalf("dcommontype %d", ot)
        }
@@ -820,10 +820,9 @@ func dcommontype(s *types.Sym, ot int, t *types.Type) int {
        //              str           nameOff
        //              ptrToThis     typeOff
        //      }
-       ot = duintptr(s.Linksym(), ot, uint64(t.Width))
-       ot = duintptr(s.Linksym(), ot, uint64(ptrdata))
-
-       ot = duint32(s.Linksym(), ot, typehash(t))
+       ot = duintptr(lsym, ot, uint64(t.Width))
+       ot = duintptr(lsym, ot, uint64(ptrdata))
+       ot = duint32(lsym, ot, typehash(t))
 
        var tflag uint8
        if uncommonSize(t) != 0 {
@@ -852,7 +851,7 @@ func dcommontype(s *types.Sym, ot int, t *types.Type) int {
                }
        }
 
-       ot = duint8(s.Linksym(), ot, tflag)
+       ot = duint8(lsym, ot, tflag)
 
        // runtime (and common sense) expects alignment to be a power of two.
        i := int(t.Align)
@@ -863,8 +862,8 @@ func dcommontype(s *types.Sym, ot int, t *types.Type) int {
        if i&(i-1) != 0 {
                Fatalf("invalid alignment %d for %v", t.Align, t)
        }
-       ot = duint8(s.Linksym(), ot, t.Align) // align
-       ot = duint8(s.Linksym(), ot, t.Align) // fieldAlign
+       ot = duint8(lsym, ot, t.Align) // align
+       ot = duint8(lsym, ot, t.Align) // fieldAlign
 
        i = kinds[t.Etype]
        if !types.Haspointers(t) {
@@ -876,23 +875,23 @@ func dcommontype(s *types.Sym, ot int, t *types.Type) int {
        if useGCProg {
                i |= objabi.KindGCProg
        }
-       ot = duint8(s.Linksym(), ot, uint8(i)) // kind
+       ot = duint8(lsym, ot, uint8(i)) // kind
        if algsym == nil {
-               ot = dsymptr(s.Linksym(), ot, algarray, int(alg)*sizeofAlg)
+               ot = dsymptr(lsym, ot, algarray, int(alg)*sizeofAlg)
        } else {
-               ot = dsymptr(s.Linksym(), ot, algsym.Linksym(), 0)
+               ot = dsymptr(lsym, ot, algsym.Linksym(), 0)
        }
-       ot = dsymptr(s.Linksym(), ot, gcsym, 0) // gcdata
+       ot = dsymptr(lsym, ot, gcsym, 0) // gcdata
 
        nsym := dname(p, "", nil, exported)
-       ot = dsymptrOff(s.Linksym(), ot, nsym, 0) // str
+       ot = dsymptrOff(lsym, ot, nsym, 0) // str
        // ptrToThis
        if sptr == nil {
-               ot = duint32(s.Linksym(), ot, 0)
+               ot = duint32(lsym, ot, 0)
        } else if sptrWeak {
-               ot = dsymptrWeakOff(s.Linksym(), ot, sptr.Linksym())
+               ot = dsymptrWeakOff(lsym, ot, sptr.Linksym())
        } else {
-               ot = dsymptrOff(s.Linksym(), ot, sptr.Linksym(), 0)
+               ot = dsymptrOff(lsym, ot, sptr.Linksym(), 0)
        }
 
        return ot
@@ -1102,34 +1101,34 @@ ok:
        ot := 0
        switch t.Etype {
        default:
-               ot = dcommontype(s, ot, t)
-               ot = dextratype(s, ot, t, 0)
+               ot = dcommontype(s.Linksym(), ot, t)
+               ot = dextratype(s.Linksym(), ot, t, 0)
 
        case TARRAY:
                // ../../../../runtime/type.go:/arrayType
                s1 := dtypesym(t.Elem())
                t2 := types.NewSlice(t.Elem())
                s2 := dtypesym(t2)
-               ot = dcommontype(s, ot, t)
+               ot = dcommontype(s.Linksym(), ot, t)
                ot = dsymptr(s.Linksym(), ot, s1.Linksym(), 0)
                ot = dsymptr(s.Linksym(), ot, s2.Linksym(), 0)
                ot = duintptr(s.Linksym(), ot, uint64(t.NumElem()))
-               ot = dextratype(s, ot, t, 0)
+               ot = dextratype(s.Linksym(), ot, t, 0)
 
        case TSLICE:
                // ../../../../runtime/type.go:/sliceType
                s1 := dtypesym(t.Elem())
-               ot = dcommontype(s, ot, t)
+               ot = dcommontype(s.Linksym(), ot, t)
                ot = dsymptr(s.Linksym(), ot, s1.Linksym(), 0)
-               ot = dextratype(s, ot, t, 0)
+               ot = dextratype(s.Linksym(), ot, t, 0)
 
        case TCHAN:
                // ../../../../runtime/type.go:/chanType
                s1 := dtypesym(t.Elem())
-               ot = dcommontype(s, ot, t)
+               ot = dcommontype(s.Linksym(), ot, t)
                ot = dsymptr(s.Linksym(), ot, s1.Linksym(), 0)
                ot = duintptr(s.Linksym(), ot, uint64(t.ChanDir()))
-               ot = dextratype(s, ot, t, 0)
+               ot = dextratype(s.Linksym(), ot, t, 0)
 
        case TFUNC:
                for _, t1 := range t.Recvs().Fields().Slice() {
@@ -1144,7 +1143,7 @@ ok:
                        dtypesym(t1.Type)
                }
 
-               ot = dcommontype(s, ot, t)
+               ot = dcommontype(s.Linksym(), ot, t)
                inCount := t.Recvs().NumFields() + t.Params().NumFields()
                outCount := t.Results().NumFields()
                if isddd {
@@ -1157,7 +1156,7 @@ ok:
                }
 
                dataAdd := (inCount + t.Results().NumFields()) * Widthptr
-               ot = dextratype(s, ot, t, dataAdd)
+               ot = dextratype(s.Linksym(), ot, t, dataAdd)
 
                // Array of rtype pointers follows funcType.
                for _, t1 := range t.Recvs().Fields().Slice() {
@@ -1178,7 +1177,7 @@ ok:
                }
 
                // ../../../../runtime/type.go:/interfaceType
-               ot = dcommontype(s, ot, t)
+               ot = dcommontype(s.Linksym(), ot, t)
 
                var tpkg *types.Pkg
                if t.Sym != nil && t != types.Types[t.Etype] && t != types.Errortype {
@@ -1190,7 +1189,7 @@ ok:
                ot = duintptr(s.Linksym(), ot, uint64(n))
                ot = duintptr(s.Linksym(), ot, uint64(n))
                dataAdd := imethodSize() * n
-               ot = dextratype(s, ot, t, dataAdd)
+               ot = dextratype(s.Linksym(), ot, t, dataAdd)
 
                lsym := s.Linksym()
                for _, a := range m {
@@ -1212,7 +1211,7 @@ ok:
                s2 := dtypesym(t.Val())
                s3 := dtypesym(mapbucket(t))
                s4 := dtypesym(hmap(t))
-               ot = dcommontype(s, ot, t)
+               ot = dcommontype(s.Linksym(), ot, t)
                ot = dsymptr(s.Linksym(), ot, s1.Linksym(), 0)
                ot = dsymptr(s.Linksym(), ot, s2.Linksym(), 0)
                ot = dsymptr(s.Linksym(), ot, s3.Linksym(), 0)
@@ -1236,13 +1235,13 @@ ok:
                ot = duint16(s.Linksym(), ot, uint16(mapbucket(t).Width))
                ot = duint8(s.Linksym(), ot, uint8(obj.Bool2int(isreflexive(t.Key()))))
                ot = duint8(s.Linksym(), ot, uint8(obj.Bool2int(needkeyupdate(t.Key()))))
-               ot = dextratype(s, ot, t, 0)
+               ot = dextratype(s.Linksym(), ot, t, 0)
 
        case TPTR32, TPTR64:
                if t.Elem().Etype == TANY {
                        // ../../../../runtime/type.go:/UnsafePointerType
-                       ot = dcommontype(s, ot, t)
-                       ot = dextratype(s, ot, t, 0)
+                       ot = dcommontype(s.Linksym(), ot, t)
+                       ot = dextratype(s.Linksym(), ot, t, 0)
 
                        break
                }
@@ -1250,9 +1249,9 @@ ok:
                // ../../../../runtime/type.go:/ptrType
                s1 := dtypesym(t.Elem())
 
-               ot = dcommontype(s, ot, t)
+               ot = dcommontype(s.Linksym(), ot, t)
                ot = dsymptr(s.Linksym(), ot, s1.Linksym(), 0)
-               ot = dextratype(s, ot, t, 0)
+               ot = dextratype(s.Linksym(), ot, t, 0)
 
        // ../../../../runtime/type.go:/structType
        // for security, only the exported fields.
@@ -1264,7 +1263,7 @@ ok:
                        n++
                }
 
-               ot = dcommontype(s, ot, t)
+               ot = dcommontype(s.Linksym(), ot, t)
                pkg := localpkg
                if t.Sym != nil {
                        pkg = t.Sym.Pkg
@@ -1284,11 +1283,11 @@ ok:
                ot = duintptr(s.Linksym(), ot, uint64(n))
 
                dataAdd := n * structfieldSize()
-               ot = dextratype(s, ot, t, dataAdd)
+               ot = dextratype(s.Linksym(), ot, t, dataAdd)
 
                for _, f := range t.Fields().Slice() {
                        // ../../../../runtime/type.go:/structField
-                       ot = dnameField(s, ot, pkg, f)
+                       ot = dnameField(s.Linksym(), ot, pkg, f)
                        ot = dsymptr(s.Linksym(), ot, dtypesym(f.Type).Linksym(), 0)
                        offsetAnon := uint64(f.Offset) << 1
                        if offsetAnon>>1 != uint64(f.Offset) {