cmd/gc: evaluate concrete == interface without allocating

Consider an interface value i of type I and concrete value c of type C.

Prior to this CL, i==c was evaluated as
	I(c) == i

As of Go 1.4, all interfaces hold pointers, so evaluating I(c) allocates.

This CL changes the evaluation of i==c to
	x, ok := i.(C); ok && x == c

The new generated code is shorter, uses less stack space,
does not allocate, and makes one runtime call instead of two.

This kind of comparison occurs in 38 places in the stdlib,
mostly in the net and os packages.

benchmark                     old ns/op     new ns/op     delta
BenchmarkCmpIfaceConcrete     31.6          7.92          -74.94%
BenchmarkCmpEfaceConcrete     29.7          7.91          -73.37%

Fixes golang#9370.

Change-Id: I7c4555950bcd6406ee5c613be1f2128da2c9a2b7

Author: josharian

src/cmd/gc/typecheck.c

@@ -575,27 +575,32 @@ typecheck1(Node **np, int top)
 			// the same type.
 			//
 			// the only conversion that isn't a no-op is concrete == interface.
-			// in that case, check comparability of the concrete type.
+			// in that case, check comparability of the concrete type,
+			// but do not do the actual conversion here, to avoid allocating.
 			if(r->type->etype != TBLANK && (aop = assignop(l->type, r->type, nil)) != 0) {
 				if(isinter(r->type) && !isinter(l->type) && algtype1(l->type, nil) == ANOEQ) {
 					yyerror("invalid operation: %N (operator %O not defined on %s)", n, op, typekind(l->type));
 					goto error;
 				}
-				l = nod(aop, l, N);
-				l->type = r->type;
-				l->typecheck = 1;
-				n->left = l;
-				t = l->type;
+				if(isinter(r->type) == isinter(l->type)) {
+					l = nod(aop, l, N);
+					l->type = r->type;
+					l->typecheck = 1;
+					n->left = l;
+				}
+				t = r->type;
 			} else if(l->type->etype != TBLANK && (aop = assignop(r->type, l->type, nil)) != 0) {
 				if(isinter(l->type) && !isinter(r->type) && algtype1(r->type, nil) == ANOEQ) {
 					yyerror("invalid operation: %N (operator %O not defined on %s)", n, op, typekind(r->type));
 					goto error;
 				}
-				r = nod(aop, r, N);
-				r->type = l->type;
-				r->typecheck = 1;
-				n->right = r;
-				t = r->type;
+				if(isinter(r->type) == isinter(l->type)) {
+					r = nod(aop, r, N);
+					r->type = l->type;
+					r->typecheck = 1;
+					n->right = r;
+				}
+				t = l->type;
 			}
 			et = t->etype;
 		}
@@ -605,8 +610,10 @@ typecheck1(Node **np, int top)
 				yyerror("invalid operation: %N (non-numeric type %T)", n, l->type);
 				goto error;
 			}
-			yyerror("invalid operation: %N (mismatched types %T and %T)", n, l->type, r->type);
-			goto error;
+			if(isinter(r->type) == isinter(l->type) || aop == 0) {
+				yyerror("invalid operation: %N (mismatched types %T and %T)", n, l->type, r->type);
+				goto error;
+			}
 		}
 		if(!okfor[op][et]) {
 			yyerror("invalid operation: %N (operator %O not defined on %s)", n, op, typekind(t));
@@ -674,7 +681,7 @@ typecheck1(Node **np, int top)
 				n->right = l;
 			} else if(r->op == OLITERAL && r->val.ctype == CTNIL) {
 				// leave alone for back end
-			} else {
+			} else if(isinter(r->type) == isinter(l->type)) {
 				n->etype = n->op;
 				n->op = OCMPIFACE;
 			}

src/cmd/gc/walk.c

@@ -3237,10 +3237,54 @@ static void
 walkcompare(Node **np, NodeList **init)
 {
 	Node *n, *l, *r, *call, *a, *li, *ri, *expr, *cmpl, *cmpr;
+	Node *x, *ok;
 	int andor, i;
 	Type *t, *t1;
 
 	n = *np;
+
+	// Given interface value l and concrete value r, rewrite
+	//   l == r
+	// to
+	//   x, ok := l.(type(r)); ok && x == r
+	// Handle != similarly.
+	// This avoids the allocation that would be required
+	// to convert r to l for comparison.
+	l = N;
+	r = N;
+	if(isinter(n->left->type) && !isinter(n->right->type)) {
+		l = n->left;
+		r = n->right;
+	} else if(!isinter(n->left->type) && isinter(n->right->type)) {
+		l = n->right;
+		r = n->left;
+	}
+	if(l != N) {
+		x = temp(r->type);
+		x->typecheck = 1;
+		ok = temp(types[TBOOL]);
+		ok->typecheck = 1;
+
+		// l.(type(r))
+		a = nod(ODOTTYPE2, l, N);
+		a->type = r->type;
+		a->typecheck = 1;
+
+		// x, ok := l.(type(r))
+		expr = nod(OAS2DOTTYPE, N, N);
+		expr->list = list1(x);
+		expr->list = list(expr->list, ok);
+		expr->rlist = list1(a);
+		expr->typecheck = 1;
+		walkexpr(&expr, init);
+
+		if(n->op == OEQ)
+			r = nod(OANDAND, ok, nod(OEQ, x, r));
+		else
+			r = nod(OOROR, nod(ONOT, ok, N), nod(ONE, x, r));
+		*init = list(*init, expr);
+		goto ret;
+	}
 
 	// Must be comparison of array or struct.
 	// Otherwise back end handles it.

src/runtime/iface_test.go

@@ -5,6 +5,7 @@
 package runtime_test
 
 import (
+	"runtime"
 	"testing"
 )
 
@@ -38,6 +39,34 @@ var (
 	tl TL
 )
 
+// Issue 9370
+func TestCmpIfaceConcreteAlloc(t *testing.T) {
+	if runtime.Compiler != "gc" {
+		t.Skip("skipping on non-gc compiler")
+	}
+
+	n := testing.AllocsPerRun(1, func() {
+		_ = e == ts
+		_ = i1 == ts
+	})
+
+	if n > 0 {
+		t.Fatalf("iface cmp allocs=%v; want 0", n)
+	}
+}
+
+func BenchmarkCmpEfaceConcrete(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_ = e == ts
+	}
+}
+
+func BenchmarkCmpIfaceConcrete(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_ = i1 == ts
+	}
+}
+
 func BenchmarkConvT2ESmall(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		e = ts

test/fixedbugs/issue9370.go

@@ -0,0 +1,56 @@
+// errorcheck
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Verify that concrete/interface comparisons are
+// typechecked correctly by the compiler.
+
+package main
+
+type I interface {
+	Method()
+}
+
+type C int
+
+func (C) Method() {}
+
+var (
+	e interface{}
+	i I
+	c C
+	n int
+)
+
+var (
+	_ = e == c
+	_ = e != c
+	_ = e >= c // ERROR "invalid operation.*not defined"
+	_ = c == e
+	_ = c != e
+	_ = c >= e // ERROR "invalid operation.*not defined"
+
+	_ = i == c
+	_ = i != c
+	_ = i >= c // ERROR "invalid operation.*not defined"
+	_ = c == i
+	_ = c != i
+	_ = c >= i // ERROR "invalid operation.*not defined"
+
+	_ = e == n
+	_ = e != n
+	_ = e >= n // ERROR "invalid operation.*not defined"
+	_ = n == e
+	_ = n != e
+	_ = n >= e // ERROR "invalid operation.*not defined"
+
+	// i and n are not assignable to each other
+	_ = i == n // ERROR "invalid operation.*mismatched types"
+	_ = i != n // ERROR "invalid operation.*mismatched types"
+	_ = i >= n // ERROR "invalid operation.*mismatched types"
+	_ = n == i // ERROR "invalid operation.*mismatched types"
+	_ = n != i // ERROR "invalid operation.*mismatched types"
+	_ = n >= i // ERROR "invalid operation.*mismatched types"
+)

test/live.go

@@ -137,10 +137,7 @@ var i9 interface{}
 func f9() bool {
 	g8()
 	x := i9
-	// using complex number in comparison so that
-	// there is always a convT2E, no matter what the
-	// interface rules are.
-	return x != 99.0i // ERROR "live at call to convT2E: x"
+	return x != 99.0i
 }
 
 // liveness formerly confused by UNDEF followed by RET,