runtime: have typelinksinit work forwards

For reasons I have forgotten typelinksinit processed modules backwards.
(I suspect this was an attempt to process types in the executing
binary first.)

It does not appear to be necessary, and it is not the order we want
when a module can be loaded at an arbitrary point during a program's
execution as a plugin. So reverse the order.

While here, make it safe to call typelinksinit multiple times.

Change-Id: Ie10587c55c8e5efa0542981efb6eb3c12dd59e8c
Reviewed-on: https://go-review.googlesource.com/27822
Reviewed-by: Ian Lance Taylor <iant@golang.org>

diff --git a/src/runtime/type.go b/src/runtime/type.go
index 5ef11a4fc4d4649cfd0a27539631ad157ab0a42a..0467c774002d9476242122ebd56e0baf94473c60 100644 (file)
--- a/src/runtime/type.go
+++ b/src/runtime/type.go
@@ -446,14 +446,11 @@ func typelinksinit() {
        if firstmoduledata.next == nil {
                return
        }
-       typehash := make(map[uint32][]*_type)
+       typehash := make(map[uint32][]*_type, len(firstmoduledata.typelinks))
 
-       modules := []*moduledata{}
-       for md := &firstmoduledata; md != nil; md = md.next {
-               modules = append(modules, md)
-       }
-       prev, modules := modules[len(modules)-1], modules[:len(modules)-1]
-       for len(modules) > 0 {
+       prev := &firstmoduledata
+       md := firstmoduledata.next
+       for md != nil {
                // Collect types from the previous module into typehash.
        collect:
                for _, tl := range prev.typelinks {
@@ -473,23 +470,25 @@ func typelinksinit() {
                        typehash[t.hash] = append(tlist, t)
                }
 
-               // If any of this module's typelinks match a type from a
-               // prior module, prefer that prior type by adding the offset
-               // to this module's typemap.
-               md := modules[len(modules)-1]
-               md.typemap = make(map[typeOff]*_type, len(md.typelinks))
-               for _, tl := range md.typelinks {
-                       t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
-                       for _, candidate := range typehash[t.hash] {
-                               if typesEqual(t, candidate) {
-                                       t = candidate
-                                       break
+               if md.typemap == nil {
+                       // If any of this module's typelinks match a type from a
+                       // prior module, prefer that prior type by adding the offset
+                       // to this module's typemap.
+                       md.typemap = make(map[typeOff]*_type, len(md.typelinks))
+                       for _, tl := range md.typelinks {
+                               t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
+                               for _, candidate := range typehash[t.hash] {
+                                       if typesEqual(t, candidate) {
+                                               t = candidate
+                                               break
+                                       }
                                }
+                               md.typemap[typeOff(tl)] = t
                        }
-                       md.typemap[typeOff(tl)] = t
                }
 
-               prev, modules = md, modules[:len(modules)-1]
+               prev = md
+               md = md.next
        }
 }