transform: refactor interrupt lowering

Instead of doing everything in the interrupt lowering pass, generate
some more code in gen-device to declare interrupt handler functions and
do some work in the compiler so that interrupt lowering becomes a lot
simpler.

This has several benefits:

  - Overall code is smaller, in particular the interrupt lowering pass.
  - The code should be a bit less "magical" and instead a bit easier to
    read. In particular, instead of having a magic
    runtime.callInterruptHandler (that is fully written by the interrupt
    lowering pass), the runtime calls a generated function like
    device/sifive.InterruptHandler where this switch already exists in
    code.
  - Debug information is improved. This can be helpful during actual
    debugging but is also useful for other uses of DWARF debug
    information.

For an example on debug information improvement, this is what a
backtrace might look like before this commit:

    Breakpoint 1, 0x00000b46 in UART0_IRQHandler ()
    (gdb) bt
    #0  0x00000b46 in UART0_IRQHandler ()
    #1  <signal handler called>
    [..etc]

Notice that the debugger doesn't see the source code location where it
has stopped.

After this commit, breaking at the same line might look like this:

    Breakpoint 1, (*machine.UART).handleInterrupt (arg1=..., uart=<optimized out>) at /home/ayke/src/github.com/tinygo-org/tinygo/src/machine/machine_nrf.go:200
    200			uart.Receive(byte(nrf.UART0.RXD.Get()))
    (gdb) bt
    #0  (*machine.UART).handleInterrupt (arg1=..., uart=<optimized out>) at /home/ayke/src/github.com/tinygo-org/tinygo/src/machine/machine_nrf.go:200
    #1  UART0_IRQHandler () at /home/ayke/src/github.com/tinygo-org/tinygo/src/device/nrf/nrf51.go:176
    tinygo-org#2  <signal handler called>
    [..etc]

By now, the debugger sees an actual source location for UART0_IRQHandler
(in the generated file) and an inlined function.

Author: aykevl

compiler/compiler.go

@@ -846,6 +846,17 @@ func (b *builder) createFunction() {
 		b.llvmFn.AddFunctionAttr(noinline)
 	}
 
+	if b.info.interrupt {
+		// Mark this function as an interrupt.
+		// This is necessary on MCUs that don't push caller saved registers when
+		// entering an interrupt, such as on AVR.
+		if strings.HasPrefix(b.Triple, "avr") {
+			b.llvmFn.AddFunctionAttr(b.ctx.CreateStringAttribute("signal", ""))
+		} else {
+			b.addError(b.fn.Pos(), "//go:interrupt not supported on this architecture")
+		}
+	}
+
 	// Add debug info, if needed.
 	if b.Debug {
 		if b.fn.Synthetic == "package initializer" {

compiler/func.go

@@ -78,11 +78,24 @@ func (b *builder) extractFuncContext(funcValue llvm.Value) llvm.Value {
 // value. This may be an expensive operation.
 func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value) {
 	context = b.CreateExtractValue(funcValue, 0, "")
-	llvmSig := b.getRawFuncType(sig)
 	switch b.FuncImplementation {
 	case "doubleword":
-		funcPtr = b.CreateBitCast(b.CreateExtractValue(funcValue, 1, ""), llvmSig, "")
+		bitcast := b.CreateExtractValue(funcValue, 1, "")
+		if !bitcast.IsAConstantExpr().IsNil() && bitcast.Opcode() == llvm.BitCast {
+			funcPtr = bitcast.Operand(0)
+			return
+		}
+		llvmSig := b.getRawFuncType(sig)
+		funcPtr = b.CreateBitCast(bitcast, llvmSig, "")
 	case "switch":
+		if !funcValue.IsAConstant().IsNil() {
+			// If this is a constant func value, the underlying function is
+			// known and can be returned directly.
+			funcValueWithSignatureGlobal := llvm.ConstExtractValue(funcValue, []uint32{1}).Operand(0)
+			funcPtr = llvm.ConstExtractValue(funcValueWithSignatureGlobal.Initializer(), []uint32{0}).Operand(0)
+			return
+		}
+		llvmSig := b.getRawFuncType(sig)
 		sigGlobal := b.getFuncSignatureID(sig)
 		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
 		funcPtr = b.CreateIntToPtr(funcPtr, llvmSig, "")

compiler/interrupt.go

@@ -36,6 +36,8 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 		// Fall back to a generic error.
 		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt function must be constant")
 	}
+	funcRawPtr, funcContext := b.decodeFuncValue(funcValue, nil)
+	funcPtr := llvm.ConstPtrToInt(funcRawPtr, b.uintptrType)
 
 	// Create a new global of type runtime/interrupt.handle. Globals of this
 	// type are lowered in the interrupt lowering pass.
@@ -47,8 +49,9 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	global.SetGlobalConstant(true)
 	global.SetUnnamedAddr(true)
 	initializer := llvm.ConstNull(globalLLVMType)
-	initializer = llvm.ConstInsertValue(initializer, funcValue, []uint32{0})
-	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(b.intType, uint64(id.Int64()), true), []uint32{1, 0})
+	initializer = llvm.ConstInsertValue(initializer, funcContext, []uint32{0})
+	initializer = llvm.ConstInsertValue(initializer, funcPtr, []uint32{1})
+	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(b.intType, uint64(id.Int64()), true), []uint32{2, 0})
 	global.SetInitializer(initializer)
 
 	// Add debug info to the interrupt global.

compiler/symbol.go

@@ -26,6 +26,7 @@ type functionInfo struct {
 	linkName   string     // go:linkname, go:export - The name that we map for the particular module -> importName
 	section    string     // go:section - object file section name
 	exported   bool       // go:export, CGo
+	interrupt  bool       // go:interrupt
 	nobounds   bool       // go:nobounds
 	variadic   bool       // go:variadic (CGo only)
 	inline     inlineType // go:inline
@@ -251,6 +252,10 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 
 				importName = parts[1]
 				info.exported = true
+			case "//go:interrupt":
+				if hasUnsafeImport(f.Pkg.Pkg) {
+					info.interrupt = true
+				}
 			case "//go:wasm-module":
 				// Alternative comment for setting the import module.
 				if len(parts) != 2 {

src/machine/machine_gameboyadvance.go

@@ -4,27 +4,28 @@ package machine
 
 import (
 	"image/color"
+	"runtime/interrupt"
 	"runtime/volatile"
 	"unsafe"
 )
 
 // Interrupt numbers as used on the GameBoy Advance. Register them with
 // runtime/interrupt.New.
 const (
-	IRQ_VBLANK  = 0
-	IRQ_HBLANK  = 1
-	IRQ_VCOUNT  = 2
-	IRQ_TIMER0  = 3
-	IRQ_TIMER1  = 4
-	IRQ_TIMER2  = 5
-	IRQ_TIMER3  = 6
-	IRQ_COM     = 7
-	IRQ_DMA0    = 8
-	IRQ_DMA1    = 9
-	IRQ_DMA2    = 10
-	IRQ_DMA3    = 11
-	IRQ_KEYPAD  = 12
-	IRQ_GAMEPAK = 13
+	IRQ_VBLANK  = interrupt.IRQ_VBLANK
+	IRQ_HBLANK  = interrupt.IRQ_HBLANK
+	IRQ_VCOUNT  = interrupt.IRQ_VCOUNT
+	IRQ_TIMER0  = interrupt.IRQ_TIMER0
+	IRQ_TIMER1  = interrupt.IRQ_TIMER1
+	IRQ_TIMER2  = interrupt.IRQ_TIMER2
+	IRQ_TIMER3  = interrupt.IRQ_TIMER3
+	IRQ_COM     = interrupt.IRQ_COM
+	IRQ_DMA0    = interrupt.IRQ_DMA0
+	IRQ_DMA1    = interrupt.IRQ_DMA1
+	IRQ_DMA2    = interrupt.IRQ_DMA2
+	IRQ_DMA3    = interrupt.IRQ_DMA3
+	IRQ_KEYPAD  = interrupt.IRQ_KEYPAD
+	IRQ_GAMEPAK = interrupt.IRQ_GAMEPAK
 )
 
 // Make it easier to directly write to I/O RAM.

src/runtime/interrupt/interrupt.go

@@ -2,6 +2,8 @@
 // to define interrupts and to enable/disable them.
 package interrupt
 
+import "unsafe"
+
 // Interrupt provides direct access to hardware interrupts. You can configure
 // this interrupt through this interface.
 //
@@ -28,6 +30,7 @@ func New(id int, handler func(Interrupt)) Interrupt
 // individually be enabled/disabled, the compiler should create a pseudo-call
 // (like runtime/interrupt.use()) that keeps the interrupt alive.
 type handle struct {
-	handler func(Interrupt)
+	context unsafe.Pointer
+	funcPtr uintptr
 	Interrupt
 }

src/runtime/interrupt/interrupt_esp32c3.go

@@ -74,7 +74,7 @@ func handleInterrupt() {
 		riscv.MSTATUS.SetBits(0x8)
 
 		// Call registered interrupt handler(s)
-		callInterruptHandler(int(interruptNumber))
+		esp.HandleInterrupt(int(interruptNumber))
 
 		// disable CPU interrupts
 		riscv.MSTATUS.ClearBits(0x8)
@@ -107,8 +107,3 @@ func handleException(mcause uintptr) {
 		riscv.Asm("wfi")
 	}
 }
-
-// callInterruptHandler is a compiler-generated function that calls the
-// appropriate interrupt handler for the given interrupt ID.
-//go:linkname callInterruptHandler runtime.callInterruptHandler
-func callInterruptHandler(id int)

src/runtime/interrupt/interrupt_gameboyadvance.go

@@ -7,6 +7,23 @@ import (
 	"unsafe"
 )
 
+const (
+	IRQ_VBLANK  = 0
+	IRQ_HBLANK  = 1
+	IRQ_VCOUNT  = 2
+	IRQ_TIMER0  = 3
+	IRQ_TIMER1  = 4
+	IRQ_TIMER2  = 5
+	IRQ_TIMER3  = 6
+	IRQ_COM     = 7
+	IRQ_DMA0    = 8
+	IRQ_DMA1    = 9
+	IRQ_DMA2    = 10
+	IRQ_DMA3    = 11
+	IRQ_KEYPAD  = 12
+	IRQ_GAMEPAK = 13
+)
+
 var (
 	regInterruptEnable       = (*volatile.Register16)(unsafe.Pointer(uintptr(0x4000200)))
 	regInterruptRequestFlags = (*volatile.Register16)(unsafe.Pointer(uintptr(0x4000202)))
@@ -30,10 +47,44 @@ func handleInterrupt() {
 	}
 }
 
-// callInterruptHandler is a compiler-generated function that calls the
-// appropriate interrupt handler for the given interrupt ID.
-//go:linkname callInterruptHandler runtime.callInterruptHandler
-func callInterruptHandler(id int)
+// Pseudo function call that is replaced by the compiler with the actual
+// functions registered through interrupt.New. If there are none, calls will be
+// replaced with 'unreachablecalls will be replaced with 'unreachable'.
+//go:linkname callHandlers runtime/interrupt.callHandlers
+func callHandlers(num int)
+
+func callInterruptHandler(id int) {
+	switch id {
+	case IRQ_VBLANK:
+		callHandlers(IRQ_VBLANK)
+	case IRQ_HBLANK:
+		callHandlers(IRQ_HBLANK)
+	case IRQ_VCOUNT:
+		callHandlers(IRQ_VCOUNT)
+	case IRQ_TIMER0:
+		callHandlers(IRQ_TIMER0)
+	case IRQ_TIMER1:
+		callHandlers(IRQ_TIMER1)
+	case IRQ_TIMER2:
+		callHandlers(IRQ_TIMER2)
+	case IRQ_TIMER3:
+		callHandlers(IRQ_TIMER3)
+	case IRQ_COM:
+		callHandlers(IRQ_COM)
+	case IRQ_DMA0:
+		callHandlers(IRQ_DMA0)
+	case IRQ_DMA1:
+		callHandlers(IRQ_DMA1)
+	case IRQ_DMA2:
+		callHandlers(IRQ_DMA2)
+	case IRQ_DMA3:
+		callHandlers(IRQ_DMA3)
+	case IRQ_KEYPAD:
+		callHandlers(IRQ_KEYPAD)
+	case IRQ_GAMEPAK:
+		callHandlers(IRQ_GAMEPAK)
+	}
+}
 
 // State represents the previous global interrupt state.
 type State uint8

src/runtime/interrupt/interrupt_hwvector.go

@@ -65,7 +65,7 @@ func handleInterrupt() {
 			// Claim this interrupt.
 			id := sifive.PLIC.CLAIM.Get()
 			// Call the interrupt handler, if any is registered for this ID.
-			callInterruptHandler(int(id))
+			sifive.HandleInterrupt(int(id))
 			// Complete this interrupt.
 			sifive.PLIC.CLAIM.Set(id)
 		}
@@ -147,7 +147,3 @@ func handleException(code uint) {
 	println()
 	abort()
 }
-
-// callInterruptHandler is a compiler-generated function that calls the
-// appropriate interrupt handler for the given interrupt ID.
-func callInterruptHandler(id int)