compiler: add support for channel operations

Support for channels is not complete. The following pieces are missing: * Channels with values bigger than int. An int in TinyGo can always contain at least a pointer, so pointers are okay to send. * Buffered channels. * The select statement.
2026-08-07 04:23:41 +00:00 · 2019-01-13 17:05:00 +01:00
parent 602c264749
commit 2e4dd09bbc
8 changed files with 502 additions and 11 deletions
@@ -0,0 +1,97 @@
+package compiler
+
+// This file lowers channel operations (make/send/recv/close) to runtime calls
+// or pseudo-operations that are lowered during goroutine lowering.
+
+import (
+	"go/types"
+
+	"github.com/aykevl/go-llvm"
+	"golang.org/x/tools/go/ssa"
+)
+
+// emitMakeChan returns a new channel value for the given channel type.
+func (c *Compiler) emitMakeChan(expr *ssa.MakeChan) (llvm.Value, error) {
+	valueType, err := c.getLLVMType(expr.Type().(*types.Chan).Elem())
+	if err != nil {
+		return llvm.Value{}, err
+	}
+	if c.targetData.TypeAllocSize(valueType) > c.targetData.TypeAllocSize(c.intType) {
+		// Values bigger than int overflow the data part of the coroutine.
+		// TODO: make the coroutine data part big enough to hold these bigger
+		// values.
+		return llvm.Value{}, c.makeError(expr.Pos(), "todo: channel with values bigger than int")
+	}
+	chanType := c.mod.GetTypeByName("runtime.channel")
+	size := c.targetData.TypeAllocSize(chanType)
+	sizeValue := llvm.ConstInt(c.uintptrType, size, false)
+	ptr := c.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "chan.alloc")
+	ptr = c.builder.CreateBitCast(ptr, llvm.PointerType(chanType, 0), "chan")
+	return ptr, nil
+}
+
+// emitChanSend emits a pseudo chan send operation. It is lowered to the actual
+// channel send operation during goroutine lowering.
+func (c *Compiler) emitChanSend(frame *Frame, instr *ssa.Send) error {
+	valueType, err := c.getLLVMType(instr.Chan.Type().(*types.Chan).Elem())
+	if err != nil {
+		return err
+	}
+	ch, err := c.parseExpr(frame, instr.Chan)
+	if err != nil {
+		return err
+	}
+	chanValue, err := c.parseExpr(frame, instr.X)
+	if err != nil {
+		return err
+	}
+	valueSize := llvm.ConstInt(c.uintptrType, c.targetData.TypeAllocSize(chanValue.Type()), false)
+	valueAlloca := c.builder.CreateAlloca(valueType, "chan.value")
+	c.builder.CreateStore(chanValue, valueAlloca)
+	valueAllocaCast := c.builder.CreateBitCast(valueAlloca, c.i8ptrType, "chan.value.i8ptr")
+	c.createRuntimeCall("chanSendStub", []llvm.Value{llvm.Undef(c.i8ptrType), ch, valueAllocaCast, valueSize}, "")
+	return nil
+}
+
+// emitChanRecv emits a pseudo chan receive operation. It is lowered to the
+// actual channel receive operation during goroutine lowering.
+func (c *Compiler) emitChanRecv(frame *Frame, unop *ssa.UnOp) (llvm.Value, error) {
+	valueType, err := c.getLLVMType(unop.X.Type().(*types.Chan).Elem())
+	if err != nil {
+		return llvm.Value{}, err
+	}
+	valueSize := llvm.ConstInt(c.uintptrType, c.targetData.TypeAllocSize(valueType), false)
+	ch, err := c.parseExpr(frame, unop.X)
+	if err != nil {
+		return llvm.Value{}, err
+	}
+	valueAlloca := c.builder.CreateAlloca(valueType, "chan.value")
+	valueAllocaCast := c.builder.CreateBitCast(valueAlloca, c.i8ptrType, "chan.value.i8ptr")
+	valueOk := c.builder.CreateAlloca(c.ctx.Int1Type(), "chan.comma-ok.alloca")
+	c.createRuntimeCall("chanRecvStub", []llvm.Value{llvm.Undef(c.i8ptrType), ch, valueAllocaCast, valueOk, valueSize}, "")
+	received := c.builder.CreateLoad(valueAlloca, "chan.received")
+	if unop.CommaOk {
+		commaOk := c.builder.CreateLoad(valueOk, "chan.comma-ok")
+		tuple := llvm.Undef(c.ctx.StructType([]llvm.Type{valueType, c.ctx.Int1Type()}, false))
+		tuple = c.builder.CreateInsertValue(tuple, received, 0, "")
+		tuple = c.builder.CreateInsertValue(tuple, commaOk, 1, "")
+		return tuple, nil
+	} else {
+		return received, nil
+	}
+}
+
+// emitChanClose closes the given channel.
+func (c *Compiler) emitChanClose(frame *Frame, param ssa.Value) error {
+	valueType, err := c.getLLVMType(param.Type().(*types.Chan).Elem())
+	valueSize := llvm.ConstInt(c.uintptrType, c.targetData.TypeAllocSize(valueType), false)
+	if err != nil {
+		return err
+	}
+	ch, err := c.parseExpr(frame, param)
+	if err != nil {
+		return err
+	}
+	c.createRuntimeCall("chanClose", []llvm.Value{ch, valueSize}, "")
+	return nil
+}
@@ -366,6 +366,8 @@ func (c *Compiler) Compile(mainPath string) error {
 	realMain.SetLinkage(llvm.ExternalLinkage) // keep alive until goroutine lowering
 	c.mod.NamedFunction("runtime.alloc").SetLinkage(llvm.ExternalLinkage)
 	c.mod.NamedFunction("runtime.free").SetLinkage(llvm.ExternalLinkage)
+	c.mod.NamedFunction("runtime.chanSend").SetLinkage(llvm.ExternalLinkage)
+	c.mod.NamedFunction("runtime.chanRecv").SetLinkage(llvm.ExternalLinkage)
 	c.mod.NamedFunction("runtime.sleepTask").SetLinkage(llvm.ExternalLinkage)
 	c.mod.NamedFunction("runtime.activateTask").SetLinkage(llvm.ExternalLinkage)
 	c.mod.NamedFunction("runtime.scheduler").SetLinkage(llvm.ExternalLinkage)
@@ -1297,6 +1299,8 @@ func (c *Compiler) parseInstr(frame *Frame, instr ssa.Instruction) error {
 		}
 	case *ssa.RunDefers:
 		return c.emitRunDefers(frame)
+	case *ssa.Send:
+		return c.emitChanSend(frame, instr)
 	case *ssa.Store:
 		llvmAddr, err := c.parseExpr(frame, instr.Addr)
 		if err == ir.ErrCGoWrapper {
@@ -1362,11 +1366,17 @@ func (c *Compiler) parseBuiltin(frame *Frame, args []ssa.Value, callName string,
 			return llvm.Value{}, err
 		}
 		switch args[0].Type().(type) {
+		case *types.Chan:
+			// Channel. Buffered channels haven't been implemented yet so always
+			// return 0.
+			return llvm.ConstInt(c.intType, 0, false), nil
 		case *types.Slice:
 			return c.builder.CreateExtractValue(value, 2, "cap"), nil
 		default:
 			return llvm.Value{}, c.makeError(pos, "todo: cap: unknown type")
 		}
+	case "close":
+		return llvm.Value{}, c.emitChanClose(frame, args[0])
 	case "complex":
 		r, err := c.parseExpr(frame, args[0])
 		if err != nil {
@@ -1434,6 +1444,10 @@ func (c *Compiler) parseBuiltin(frame *Frame, args []ssa.Value, callName string,
 		case *types.Basic, *types.Slice:
 			// string or slice
 			llvmLen = c.builder.CreateExtractValue(value, 1, "len")
+		case *types.Chan:
+			// Channel. Buffered channels haven't been implemented yet so always
+			// return 0.
+			llvmLen = llvm.ConstInt(c.intType, 0, false)
 		case *types.Map:
 			llvmLen = c.createRuntimeCall("hashmapLen", []llvm.Value{value}, "len")
 		default:
@@ -2000,12 +2014,12 @@ func (c *Compiler) parseExpr(frame *Frame, expr ssa.Value) (llvm.Value, error) {
 		default:
 			panic("unknown lookup type: " + expr.String())
 		}
-
+	case *ssa.MakeChan:
+		return c.emitMakeChan(expr)
 	case *ssa.MakeClosure:
 		// A closure returns a function pointer with context:
 		// {context, fp}
 		return c.parseMakeClosure(frame, expr)
-
 	case *ssa.MakeInterface:
 		val, err := c.parseExpr(frame, expr.X)
 		if err != nil {
@@ -2941,6 +2955,8 @@ func (c *Compiler) parseUnOp(frame *Frame, unop *ssa.UnOp) (llvm.Value, error) {
 		}
 	case token.XOR: // ^x, toggle all bits in integer
 		return c.builder.CreateXor(x, llvm.ConstInt(x.Type(), ^uint64(0), false), ""), nil
+	case token.ARROW: // <-x, receive from channel
+		return c.emitChanRecv(frame, unop)
 	default:
 		return llvm.Value{}, c.makeError(unop.Pos(), "todo: unknown unop")
 	}
@@ -142,6 +142,8 @@ func (c *Compiler) LowerGoroutines() error {
 	realMain.SetLinkage(llvm.InternalLinkage)
 	c.mod.NamedFunction("runtime.alloc").SetLinkage(llvm.InternalLinkage)
 	c.mod.NamedFunction("runtime.free").SetLinkage(llvm.InternalLinkage)
+	c.mod.NamedFunction("runtime.chanSend").SetLinkage(llvm.InternalLinkage)
+	c.mod.NamedFunction("runtime.chanRecv").SetLinkage(llvm.InternalLinkage)
 	c.mod.NamedFunction("runtime.sleepTask").SetLinkage(llvm.InternalLinkage)
 	c.mod.NamedFunction("runtime.activateTask").SetLinkage(llvm.InternalLinkage)
 	c.mod.NamedFunction("runtime.scheduler").SetLinkage(llvm.InternalLinkage)
@@ -162,8 +164,22 @@ func (c *Compiler) LowerGoroutines() error {
 //    * Set up the coroutine frames for async functions.
 //    * Transform blocking calls into their async equivalents.
 func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
+	var worklist []llvm.Value
+
 	sleep := c.mod.NamedFunction("time.Sleep")
-	if sleep.IsNil() {
+	if !sleep.IsNil() {
+		worklist = append(worklist, sleep)
+	}
+	chanSendStub := c.mod.NamedFunction("runtime.chanSendStub")
+	if !chanSendStub.IsNil() {
+		worklist = append(worklist, chanSendStub)
+	}
+	chanRecvStub := c.mod.NamedFunction("runtime.chanRecvStub")
+	if !chanRecvStub.IsNil() {
+		worklist = append(worklist, chanRecvStub)
+	}
+
+	if len(worklist) == 0 {
 		// There are no blocking operations, so no need to transform anything.
 		return false, c.lowerMakeGoroutineCalls()
 	}
@@ -173,7 +189,6 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 	// from the worklist and pushing all its parents that are non-async.
 	// This is somewhat similar to a worklist in a mark-sweep garbage collector:
 	// the work items are then grey objects.
-	worklist := []llvm.Value{sleep}
 	asyncFuncs := make(map[llvm.Value]*asyncFunc)
 	asyncList := make([]llvm.Value, 0, 4)
 	for len(worklist) != 0 {
@@ -259,6 +274,9 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 	coroBeginType := llvm.FunctionType(c.i8ptrType, []llvm.Type{c.ctx.TokenType(), c.i8ptrType}, false)
 	coroBeginFunc := llvm.AddFunction(c.mod, "llvm.coro.begin", coroBeginType)

+	coroPromiseType := llvm.FunctionType(c.i8ptrType, []llvm.Type{c.i8ptrType, c.ctx.Int32Type(), c.ctx.Int1Type()}, false)
+	coroPromiseFunc := llvm.AddFunction(c.mod, "llvm.coro.promise", coroPromiseType)
+
 	coroSuspendType := llvm.FunctionType(c.ctx.Int8Type(), []llvm.Type{c.ctx.TokenType(), c.ctx.Int1Type()}, false)
 	coroSuspendFunc := llvm.AddFunction(c.mod, "llvm.coro.suspend", coroSuspendType)

@@ -270,7 +288,7 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {

 	// Transform all async functions into coroutines.
 	for _, f := range asyncList {
-		if f == sleep {
+		if f == sleep || f == chanSendStub || f == chanRecvStub {
 			continue
 		}

@@ -287,7 +305,7 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 			for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
 				if !inst.IsACallInst().IsNil() {
 					callee := inst.CalledValue()
-					if _, ok := asyncFuncs[callee]; !ok || callee == sleep {
+					if _, ok := asyncFuncs[callee]; !ok || callee == sleep || callee == chanSendStub || callee == chanRecvStub {
 						continue
 					}
 					asyncCalls = append(asyncCalls, inst)
@@ -421,6 +439,103 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 		sleepCall.EraseFromParentAsInstruction()
 	}

+	// Transform calls to runtime.chanSendStub into channel send operations.
+	for _, sendOp := range getUses(chanSendStub) {
+		// sendOp must be a call instruction.
+		frame := asyncFuncs[sendOp.InstructionParent().Parent()]
+
+		// Send the value over the channel, or block.
+		sendOp.SetOperand(0, frame.taskHandle)
+		sendOp.SetOperand(sendOp.OperandsCount()-1, c.mod.NamedFunction("runtime.chanSend"))
+
+		// Use taskState.data to store the value to send:
+		//     *(*valueType)(&coroutine.promise().data) = valueToSend
+		//     runtime.chanSend(coroutine, ch)
+		bitcast := sendOp.Operand(2)
+		valueAlloca := bitcast.Operand(0)
+		c.builder.SetInsertPointBefore(valueAlloca)
+		promiseType := c.mod.GetTypeByName("runtime.taskState")
+		promiseRaw := c.builder.CreateCall(coroPromiseFunc, []llvm.Value{
+			frame.taskHandle,
+			llvm.ConstInt(c.ctx.Int32Type(), uint64(c.targetData.PrefTypeAlignment(promiseType)), false),
+			llvm.ConstInt(c.ctx.Int1Type(), 0, false),
+		}, "task.promise.raw")
+		promise := c.builder.CreateBitCast(promiseRaw, llvm.PointerType(promiseType, 0), "task.promise")
+		dataPtr := c.builder.CreateGEP(promise, []llvm.Value{
+			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(c.ctx.Int32Type(), 2, false),
+		}, "task.promise.data")
+		sendOp.SetOperand(2, llvm.Undef(c.i8ptrType))
+		valueAlloca.ReplaceAllUsesWith(c.builder.CreateBitCast(dataPtr, valueAlloca.Type(), ""))
+		bitcast.EraseFromParentAsInstruction()
+		valueAlloca.EraseFromParentAsInstruction()
+
+		// Yield to scheduler.
+		c.builder.SetInsertPointBefore(llvm.NextInstruction(sendOp))
+		continuePoint := c.builder.CreateCall(coroSuspendFunc, []llvm.Value{
+			llvm.ConstNull(c.ctx.TokenType()),
+			llvm.ConstInt(c.ctx.Int1Type(), 0, false),
+		}, "")
+		sw := c.builder.CreateSwitch(continuePoint, frame.suspendBlock, 2)
+		wakeup := c.splitBasicBlock(sw, llvm.NextBasicBlock(c.builder.GetInsertBlock()), "task.sent")
+		sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 0, false), wakeup)
+		sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 1, false), frame.cleanupBlock)
+	}
+
+	// Transform calls to runtime.chanRecvStub into channel receive operations.
+	for _, recvOp := range getUses(chanRecvStub) {
+		// recvOp must be a call instruction.
+		frame := asyncFuncs[recvOp.InstructionParent().Parent()]
+
+		bitcast := recvOp.Operand(2)
+		commaOk := recvOp.Operand(3)
+		valueAlloca := bitcast.Operand(0)
+
+		// Receive the value over the channel, or block.
+		recvOp.SetOperand(0, frame.taskHandle)
+		recvOp.SetOperand(recvOp.OperandsCount()-1, c.mod.NamedFunction("runtime.chanRecv"))
+		recvOp.SetOperand(2, llvm.Undef(c.i8ptrType))
+		bitcast.EraseFromParentAsInstruction()
+
+		// Yield to scheduler.
+		c.builder.SetInsertPointBefore(llvm.NextInstruction(recvOp))
+		continuePoint := c.builder.CreateCall(coroSuspendFunc, []llvm.Value{
+			llvm.ConstNull(c.ctx.TokenType()),
+			llvm.ConstInt(c.ctx.Int1Type(), 0, false),
+		}, "")
+		sw := c.builder.CreateSwitch(continuePoint, frame.suspendBlock, 2)
+		wakeup := c.splitBasicBlock(sw, llvm.NextBasicBlock(c.builder.GetInsertBlock()), "task.received")
+		c.builder.SetInsertPointAtEnd(recvOp.InstructionParent())
+		sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 0, false), wakeup)
+		sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 1, false), frame.cleanupBlock)
+
+		// The value to receive is stored in taskState.data:
+		//     runtime.chanRecv(coroutine, ch)
+		//     promise := coroutine.promise()
+		//     valueReceived := *(*valueType)(&promise.data)
+		//     ok := promise.commaOk
+		c.builder.SetInsertPointBefore(wakeup.FirstInstruction())
+		promiseType := c.mod.GetTypeByName("runtime.taskState")
+		promiseRaw := c.builder.CreateCall(coroPromiseFunc, []llvm.Value{
+			frame.taskHandle,
+			llvm.ConstInt(c.ctx.Int32Type(), uint64(c.targetData.PrefTypeAlignment(promiseType)), false),
+			llvm.ConstInt(c.ctx.Int1Type(), 0, false),
+		}, "task.promise.raw")
+		promise := c.builder.CreateBitCast(promiseRaw, llvm.PointerType(promiseType, 0), "task.promise")
+		dataPtr := c.builder.CreateGEP(promise, []llvm.Value{
+			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(c.ctx.Int32Type(), 2, false),
+		}, "task.promise.data")
+		valueAlloca.ReplaceAllUsesWith(c.builder.CreateBitCast(dataPtr, valueAlloca.Type(), ""))
+		valueAlloca.EraseFromParentAsInstruction()
+		commaOkPtr := c.builder.CreateGEP(promise, []llvm.Value{
+			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(c.ctx.Int32Type(), 1, false),
+		}, "task.promise.comma-ok")
+		commaOk.ReplaceAllUsesWith(commaOkPtr)
+		recvOp.SetOperand(3, llvm.Undef(commaOk.Type()))
+	}
+
 	return true, c.lowerMakeGoroutineCalls()
 }