From bee42067649390557c772c561e02d46b3f066fe3 Mon Sep 17 00:00:00 2001 From: David Crawshaw Date: Thu, 25 Aug 2016 22:19:16 -0400 Subject: [PATCH] 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 --- src/runtime/type.go | 39 +++++++++++++++++++-------------------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/src/runtime/type.go b/src/runtime/type.go index 5ef11a4fc4..0467c77400 100644 --- 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 } } -- 2.48.1