compiler: add support for the go keyword on interface methods

compiler/compiler.go

@@ -1342,9 +1342,9 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 //
 // This is also where compiler intrinsics are implemented.
 func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error) {
-	if instr.IsInvoke() {
-		fnCast, args := b.getInvokeCall(instr)
-		return b.createCall(fnCast, args, ""), nil
+	var params []llvm.Value
+	for _, param := range instr.Args {
+		params = append(params, b.getValue(param))
 	}
 
 	// Try to call the function directly for trivially static calls.
@@ -1415,12 +1415,20 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 	} else if call, ok := instr.Value.(*ssa.Builtin); ok {
 		// Builtin function (append, close, delete, etc.).)
 		var argTypes []types.Type
-		var argValues []llvm.Value
 		for _, arg := range instr.Args {
 			argTypes = append(argTypes, arg.Type())
-			argValues = append(argValues, b.getValue(arg))
 		}
-		return b.createBuiltin(argTypes, argValues, call.Name(), instr.Pos())
+		return b.createBuiltin(argTypes, params, call.Name(), instr.Pos())
+	} else if instr.IsInvoke() {
+		// Interface method call (aka invoke call).
+		itf := b.getValue(instr.Value) // interface value (runtime._interface)
+		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
+		value := b.CreateExtractValue(itf, 1, "invoke.func.value") // receiver
+		// Prefix the params with receiver value and suffix with typecode.
+		params = append([]llvm.Value{value}, params...)
+		params = append(params, typecode)
+		callee = b.getInvokeFunction(instr)
+		context = llvm.Undef(b.i8ptrType)
 	} else {
 		// Function pointer.
 		value := b.getValue(instr.Value)
@@ -1430,11 +1438,6 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		b.createNilCheck(instr.Value, callee, "fpcall")
 	}
 
-	var params []llvm.Value
-	for _, param := range instr.Args {
-		params = append(params, b.getValue(param))
-	}
-
 	if !exported {
 		// This function takes a context parameter.
 		// Add it to the end of the parameter list.

compiler/defer.go

@@ -331,10 +331,10 @@ func (b *builder) createRunDefers() {
 				//Pass context
 				forwardParams = append(forwardParams, context)
 			} else {
-				// Isolate the typecode.
-				typecode := forwardParams[0]
-				forwardParams = forwardParams[1:]
-				fnPtr = b.getInvokePtr(callback, typecode)
+				// Move typecode from the start to the end of the list of
+				// parameters.
+				forwardParams = append(forwardParams[1:], forwardParams[0])
+				fnPtr = b.getInvokeFunction(callback)
 
 				// Add the context parameter. An interface call cannot also be a
 				// closure but we have to supply the parameter anyway for platforms

compiler/goroutine.go

@@ -79,7 +79,15 @@ func (b *builder) createGo(instr *ssa.Go) {
 		}
 		b.createBuiltin(argTypes, argValues, builtin.Name(), instr.Pos())
 		return
-	} else if !instr.Call.IsInvoke() {
+	} else if instr.Call.IsInvoke() {
+		// This is a method call on an interface value.
+		itf := b.getValue(instr.Call.Value)
+		itfTypeCode := b.CreateExtractValue(itf, 0, "")
+		itfValue := b.CreateExtractValue(itf, 1, "")
+		funcPtr = b.getInvokeFunction(&instr.Call)
+		params = append([]llvm.Value{itfValue}, params...) // start with receiver
+		params = append(params, itfTypeCode)               // end with typecode
+	} else {
 		// This is a function pointer.
 		// At the moment, two extra params are passed to the newly started
 		// goroutine:
@@ -99,9 +107,6 @@ func (b *builder) createGo(instr *ssa.Go) {
 			panic("unknown scheduler type")
 		}
 		prefix = b.fn.RelString(nil)
-	} else {
-		b.addError(instr.Pos(), "todo: go on interface call")
-		return
 	}
 
 	paramBundle := b.emitPointerPack(params)

compiler/interface.go

@@ -47,6 +47,7 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		var length int64
 		var methodSet llvm.Value
 		var ptrTo llvm.Value
+		var typeAssert llvm.Value
 		switch typ := typ.(type) {
 		case *types.Named:
 			references = c.getTypeCode(typ.Underlying())
@@ -69,6 +70,9 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		}
 		if _, ok := typ.Underlying().(*types.Interface); !ok {
 			methodSet = c.getTypeMethodSet(typ)
+		} else {
+			typeAssert = c.getInterfaceImplementsFunc(typ)
+			typeAssert = llvm.ConstPtrToInt(typeAssert, c.uintptrType)
 		}
 		if _, ok := typ.Underlying().(*types.Pointer); !ok {
 			ptrTo = c.getTypeCode(types.NewPointer(typ))
@@ -87,6 +91,9 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		if !ptrTo.IsNil() {
 			globalValue = llvm.ConstInsertValue(globalValue, ptrTo, []uint32{3})
 		}
+		if !typeAssert.IsNil() {
+			globalValue = llvm.ConstInsertValue(globalValue, typeAssert, []uint32{4})
+		}
 		global.SetInitializer(globalValue)
 		global.SetLinkage(llvm.LinkOnceODRLinkage)
 		global.SetGlobalConstant(true)
@@ -193,7 +200,11 @@ func getTypeCodeName(t types.Type) string {
 	case *types.Interface:
 		methods := make([]string, t.NumMethods())
 		for i := 0; i < t.NumMethods(); i++ {
-			methods[i] = t.Method(i).Name() + ":" + getTypeCodeName(t.Method(i).Type())
+			name := t.Method(i).Name()
+			if !token.IsExported(name) {
+				name = t.Method(i).Pkg().Path() + "." + name
+			}
+			methods[i] = name + ":" + getTypeCodeName(t.Method(i).Type())
 		}
 		return "interface:" + "{" + strings.Join(methods, ",") + "}"
 	case *types.Map:
@@ -306,17 +317,24 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 }
 
-// getMethodSignature returns a global variable which is a reference to an
-// external *i8 indicating the indicating the signature of this method. It is
-// used during the interface lowering pass.
-func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
+// getMethodSignatureName returns a unique name (that can be used as the name of
+// a global) for the given method.
+func (c *compilerContext) getMethodSignatureName(method *types.Func) string {
 	signature := methodSignature(method)
 	var globalName string
 	if token.IsExported(method.Name()) {
 		globalName = "reflect/methods." + signature
 	} else {
 		globalName = method.Type().(*types.Signature).Recv().Pkg().Path() + ".$methods." + signature
 	}
+	return globalName
+}
+
+// getMethodSignature returns a global variable which is a reference to an
+// external *i8 indicating the indicating the signature of this method. It is
+// used during the interface lowering pass.
+func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
+	globalName := c.getMethodSignatureName(method)
 	signatureGlobal := c.mod.NamedGlobal(globalName)
 	if signatureGlobal.IsNil() {
 		// TODO: put something useful in these globals, such as the method
@@ -345,15 +363,16 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	commaOk := llvm.Value{}
 	if _, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
 		// Type assert on interface type.
-		// This pseudo call will be lowered in the interface lowering pass to a
-		// real call which checks whether the provided typecode is any of the
-		// concrete types that implements this interface.
+		// This is a call to an interface type assert function.
+		// The interface lowering pass will define this function by filling it
+		// with a type switch over all concrete types that implement this
+		// interface, and returning whether it's one of the matched types.
 		// This is very different from how interface asserts are implemented in
 		// the main Go compiler, where the runtime checks whether the type
 		// implements each method of the interface. See:
 		// https://research.swtch.com/interfaces
-		methodSet := b.getInterfaceMethodSet(expr.AssertedType)
-		commaOk = b.createRuntimeCall("interfaceImplements", []llvm.Value{actualTypeNum, methodSet}, "")
+		fn := b.getInterfaceImplementsFunc(expr.AssertedType)
+		commaOk = b.CreateCall(fn, []llvm.Value{actualTypeNum}, "")
 
 	} else {
 		globalName := "reflect/types.typeid:" + getTypeCodeName(expr.AssertedType)
@@ -420,39 +439,50 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	}
 }
 
-// getInvokePtr creates an interface function pointer lookup for the specified invoke instruction, using a specified typecode.
-func (b *builder) getInvokePtr(instr *ssa.CallCommon, typecode llvm.Value) llvm.Value {
-	llvmFnType := b.getRawFuncType(instr.Method.Type().(*types.Signature))
-	values := []llvm.Value{
-		typecode,
-		b.getInterfaceMethodSet(instr.Value.Type()),
-		b.getMethodSignature(instr.Method),
+// getMethodsString returns a string to be used in the "tinygo-methods" string
+// attribute for interface functions.
+func (c *compilerContext) getMethodsString(itf *types.Interface) string {
+	methods := make([]string, itf.NumMethods())
+	for i := range methods {
+		methods[i] = c.getMethodSignatureName(itf.Method(i))
 	}
-	fn := b.createRuntimeCall("interfaceMethod", values, "invoke.func")
-	return b.CreateIntToPtr(fn, llvmFnType, "invoke.func.cast")
+	return strings.Join(methods, "; ")
 }
 
-// getInvokeCall creates and returns the function pointer and parameters of an
-// interface call.
-func (b *builder) getInvokeCall(instr *ssa.CallCommon) (llvm.Value, []llvm.Value) {
-	// Call an interface method with dynamic dispatch.
-	itf := b.getValue(instr.Value) // interface
-
-	typecode := b.CreateExtractValue(itf, 0, "invoke.typecode")
-	fnCast := b.getInvokePtr(instr, typecode)
-	receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")
-
-	args := []llvm.Value{receiverValue}
-	for _, arg := range instr.Args {
-		args = append(args, b.getValue(arg))
+// getInterfaceImplementsfunc returns a declared function that works as a type
+// switch. The interface lowering pass will define this function.
+func (c *compilerContext) getInterfaceImplementsFunc(assertedType types.Type) llvm.Value {
+	fnName := getTypeCodeName(assertedType.Underlying()) + ".$typeassert"
+	llvmFn := c.mod.NamedFunction(fnName)
+	if llvmFn.IsNil() {
+		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.uintptrType}, false)
+		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
+		methods := c.getMethodsString(assertedType.Underlying().(*types.Interface))
+		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-methods", methods))
 	}
-	// Add the context parameter. An interface call never takes a context but we
-	// have to supply the parameter anyway.
-	args = append(args, llvm.Undef(b.i8ptrType))
-	// Add the parent goroutine handle.
-	args = append(args, llvm.Undef(b.i8ptrType))
+	return llvmFn
+}
 
-	return fnCast, args
+// getInvokeFunction returns the thunk to call the given interface method. The
+// thunk is declared, not defined: it will be defined by the interface lowering
+// pass.
+func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
+	fnName := getTypeCodeName(instr.Value.Type().Underlying()) + "." + instr.Method.Name() + "$invoke"
+	llvmFn := c.mod.NamedFunction(fnName)
+	if llvmFn.IsNil() {
+		sig := instr.Method.Type().(*types.Signature)
+		var paramTuple []*types.Var
+		for i := 0; i < sig.Params().Len(); i++ {
+			paramTuple = append(paramTuple, sig.Params().At(i))
+		}
+		paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.Uintptr]))
+		llvmFnType := c.getRawFuncType(types.NewSignature(sig.Recv(), types.NewTuple(paramTuple...), sig.Results(), false)).ElementType()
+		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
+		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-invoke", c.getMethodSignatureName(instr.Method)))
+		methods := c.getMethodsString(instr.Value.Type().Underlying().(*types.Interface))
+		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-methods", methods))
+	}
+	return llvmFn
 }
 
 // getInterfaceInvokeWrapper returns a wrapper for the given method so it can be

compiler/testdata/goroutine-cortex-m-qemu.ll

@@ -9,6 +9,8 @@ target triple = "armv7m-unknown-unknown-eabi"
 %"internal/task.state" = type { i32, i32* }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }
 
+@"main.startInterfaceMethod$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
+
 declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
 ; Function Attrs: nounwind
@@ -158,8 +160,50 @@ entry:
 
 declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
 
+; Function Attrs: nounwind
+define hidden void @main.startInterfaceMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i8* @runtime.alloc(i32 16, i8* undef, i8* null) #0
+  %1 = bitcast i8* %0 to i8**
+  store i8* %itf.value, i8** %1, align 4
+  %2 = getelementptr inbounds i8, i8* %0, i32 4
+  %.repack = bitcast i8* %2 to i8**
+  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main.startInterfaceMethod$string", i32 0, i32 0), i8** %.repack, align 4
+  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
+  %3 = bitcast i8* %.repack1 to i32*
+  store i32 4, i32* %3, align 4
+  %4 = getelementptr inbounds i8, i8* %0, i32 12
+  %5 = bitcast i8* %4 to i32*
+  store i32 %itf.typecode, i32* %5, align 4
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null) #0
+  ret void
+}
+
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*, i8*) #5
+
+; Function Attrs: nounwind
+define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(i8* %0) unnamed_addr #6 {
+entry:
+  %1 = bitcast i8* %0 to i8**
+  %2 = load i8*, i8** %1, align 4
+  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %4 = bitcast i8* %3 to i8**
+  %5 = load i8*, i8** %4, align 4
+  %6 = getelementptr inbounds i8, i8* %0, i32 8
+  %7 = bitcast i8* %6 to i32*
+  %8 = load i32, i32* %7, align 4
+  %9 = getelementptr inbounds i8, i8* %0, i32 12
+  %10 = bitcast i8* %9 to i32*
+  %11 = load i32, i32* %10, align 4
+  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8* %2, i8* %5, i32 %8, i32 %11, i8* undef, i8* undef) #0
+  ret void
+}
+
 attributes #0 = { nounwind }
 attributes #1 = { nounwind "tinygo-gowrapper"="main.regularFunction" }
 attributes #2 = { nounwind "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
 attributes #3 = { nounwind "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
 attributes #4 = { nounwind "tinygo-gowrapper" }
+attributes #5 = { "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
+attributes #6 = { nounwind "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }

compiler/testdata/goroutine-wasm.ll

@@ -14,6 +14,7 @@ target triple = "wasm32-unknown-wasi"
 @"main.inlineFunctionGoroutine$pack" = private unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
 @"reflect/types.funcid:func:{basic:int}{}" = external constant i8
 @"main.closureFunctionGoroutine$1$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }
+@"main.startInterfaceMethod$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
 
 declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
 
@@ -115,4 +116,26 @@ entry:
 
 declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
 
+; Function Attrs: nounwind
+define hidden void @main.startInterfaceMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i8* @runtime.alloc(i32 16, i8* undef, i8* null) #0
+  %1 = bitcast i8* %0 to i8**
+  store i8* %itf.value, i8** %1, align 4
+  %2 = getelementptr inbounds i8, i8* %0, i32 4
+  %.repack = bitcast i8* %2 to i8**
+  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main.startInterfaceMethod$string", i32 0, i32 0), i8** %.repack, align 4
+  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
+  %3 = bitcast i8* %.repack1 to i32*
+  store i32 4, i32* %3, align 4
+  %4 = getelementptr inbounds i8, i8* %0, i32 12
+  %5 = bitcast i8* %4 to i32*
+  store i32 %itf.typecode, i32* %5, align 4
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*, i8*, i32, i32, i8*, i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke" to i32), i8* nonnull %0, i32 undef, i8* undef, i8* null) #0
+  ret void
+}
+
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*, i8*) #1
+
 attributes #0 = { nounwind }
+attributes #1 = { "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }

compiler/testdata/goroutine.go

@@ -41,3 +41,11 @@ func closeBuiltinGoroutine(ch chan int) {
 }
 
 func regularFunction(x int)
+
+type simpleInterface interface {
+	Print(string)
+}
+
+func startInterfaceMethod(itf simpleInterface) {
+	go itf.Print("test")
+}

compiler/testdata/interface.go

@@ -49,6 +49,15 @@ func isStringer(itf interface{}) bool {
 	return ok
 }
 
+type fooInterface interface {
+	String() string
+	foo(int) byte
+}
+
+func callFooMethod(itf fooInterface) uint8 {
+	return itf.foo(3)
+}
+
 func callErrorMethod(itf error) string {
 	return itf.Error()
 }