update

Change-Id: I47372cc2a2f18fb843572757902b1730dd963bde

Author: mateusz834

src/cmd/compile/internal/base/debug.go

@@ -75,7 +75,6 @@ type DebugFlags struct {
 	WrapGlobalMapDbg      int    `help:"debug trace output for global map init wrapping"`
 	WrapGlobalMapCtl      int    `help:"global map init wrap control (0 => default, 1 => off, 2 => stress mode, no size cutoff)"`
 	ZeroCopy              int    `help:"enable zero-copy string->[]byte conversions" concurrent:"ok"`
-	Testing               int    `help:"enable zero-copy string->[]byte conversions" concurrent:"ok"`
 
 	ConcurrentOk bool // true if only concurrentOk flags seen
 }

src/cmd/compile/internal/devirtualize/devirtualize.go

@@ -127,13 +127,13 @@ func StaticCall(call *ir.CallExpr) {
 		// 	v.A()
 		// 	v = &Impl{}
 		//
-		// Here in the devirtualizer, we determine the concrete type of v as beeing an *Impl, but
-		// in can still be a nil interface, but we have not detected that. It is not a huge problem as
-		// the v.(*Impl) type assertion that we make here would also have failed, but with a different
+		// Here in the devirtualizer, we determine the concrete type of v as beeing an *Impl,
+		// but in can still be a nil interface, we have not detected that. The v.(*Impl)
+		// type assertion that we make here would also have failed, but with a different
 		// panic "pkg.Iface is nil, not *pkg.Impl", where previously we would get a nil panic.
 		// We fix this, by introducing an additional nilcheck on the itab.
-		nilCheck := ir.NewUnaryExpr(call.Pos(), ir.OCHECKNIL, ir.NewUnaryExpr(call.Pos(), ir.OITAB, sel.X))
-		dt.PtrInit().Append(typecheck.Stmt(nilCheck))
+		dt.EmitItabNilCheck = true
+		dt.SetPos(call.Pos())
 	}
 
 	x := typecheck.XDotMethod(sel.Pos(), dt, sel.Sel, true)
@@ -174,14 +174,12 @@ func StaticCall(call *ir.CallExpr) {
 	typecheck.FixMethodCall(call)
 }
 
-// const concreteTypeDebug = false
-var concreteTypeDebug = false
+const concreteTypeDebug = false
 
 // concreteType determines the concrete type of n, following OCONVIFACEs and type asserts.
 // Returns nil when the concrete type could not be determined, or when there are multiple
 // (different) types assigned to an interface.
 func concreteType(n ir.Node) (typ *types.Type) {
-	concreteTypeDebug = base.Debug.Testing != 0
 	return concreteType1(n, make(map[*ir.Name]*types.Type))
 }
 

src/cmd/compile/internal/ir/expr.go

@@ -677,6 +677,9 @@ type TypeAssertExpr struct {
 
 	// An internal/abi.TypeAssert descriptor to pass to the runtime.
 	Descriptor *obj.LSym
+
+	// Emit a nilcheck on the Itab of X.
+	EmitItabNilCheck bool
 }
 
 func NewTypeAssertExpr(pos src.XPos, x Node, typ *types.Type) *TypeAssertExpr {

src/cmd/compile/internal/ssagen/ssa.go

@@ -5625,6 +5625,17 @@ func (s *state) dottype(n *ir.TypeAssertExpr, commaok bool) (res, resok *ssa.Val
 	if n.ITab != nil {
 		targetItab = s.expr(n.ITab)
 	}
+
+	if n.EmitItabNilCheck {
+		typs := s.f.Config.Types
+		iface = s.newValue2(
+			ssa.OpIMake,
+			iface.Type,
+			s.nilCheck(s.newValue1(ssa.OpITab, typs.BytePtr, iface)),
+			s.newValue1(ssa.OpIData, typs.BytePtr, iface),
+		)
+	}
+
 	return s.dottype1(n.Pos(), n.X.Type(), n.Type(), iface, nil, target, targetItab, commaok, n.Descriptor)
 }