[dev.typeparams] cmd/compile: do extra markObjects during iexport to deal with generics

markInlBody/markObject/markType don't fully work as they stand for
generic functions/methods, since markInlBody can't understand method
calls on generic types. Those method calls will be resolved to concrete
methods in a full instantiation, but markInlBody on a generic
function/method can't understand those method calls. So, we won't
necessarily cause export of the appropriate extra method/function bodies
needed for inlining in an instantiated function.

One way to do this is just to make sure that we call markType
on all generic types that are exported (whether explicitly exported via
a capitalized name or unexported types that are referenced by a generic
function body). That way, we will call markInlBody on all possible
generic methods that might be called.

Fixes the current problem for i386-softfloat builds on dev.typeparams.

Change-Id: I2d3625d26042296731bd3c44ba1938aa194d527e
Reviewed-on: https://go-review.googlesource.com/c/go/+/325329
Run-TryBot: Dan Scales <danscales@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Trust: Dan Scales <danscales@google.com>

diff --git a/src/cmd/compile/internal/typecheck/crawler.go b/src/cmd/compile/internal/typecheck/crawler.go
index 48fc61dbfd9a21045bffb30053991d077ef32f4d..c78a604a8d2898861fcdf896278b61c4eb56597c 100644 (file)
--- a/src/cmd/compile/internal/typecheck/crawler.go
+++ b/src/cmd/compile/internal/typecheck/crawler.go
@@ -146,7 +146,9 @@ func (p *crawler) markInlBody(n *ir.Name) {
                        case ir.PEXTERN:
                                Export(n)
                        }
-
+                       p.checkGenericType(n.Type())
+               case ir.OTYPE:
+                       p.checkGenericType(n.Type())
                case ir.OCALLPART:
                        // Okay, because we don't yet inline indirect
                        // calls to method values.
@@ -162,3 +164,16 @@ func (p *crawler) markInlBody(n *ir.Name) {
        // because after inlining they might be callable.
        ir.VisitList(fn.Inl.Body, doFlood)
 }
+
+// checkGenerictype ensures that we call markType() on any base generic type that
+// is written to the export file (even if not explicitly marked
+// for export), so its methods will be available for inlining if needed.
+func (p *crawler) checkGenericType(t *types.Type) {
+       if t != nil && t.HasTParam() {
+               if t.OrigSym != nil {
+                       // Convert to the base generic type.
+                       t = t.OrigSym.Def.Type()
+               }
+               p.markType(t)
+       }
+}