runtime, internal/task: refactor to simplify stack switching

The Cortex-M target isn't much changed, but much of the logic for the
AVR stack switcher that was previously in assembly has now been moved to
Go to make it more maintainable and in fact smaller in code size. Three
functions (tinygo_getCurrentStackPointer, tinygo_switchToTask,
tinygo_switchToScheduler) have been changed to one: tinygo_swapTask.

This reduction in assembly code should make the code more maintainable
and should make it easier to port stack switching to other
architectures.

I've also moved the assembly files to src/internal/task, which seems
like a more appropriate location to me.

src/internal/task/task_stack.go

@@ -45,6 +45,11 @@ func Pause() {
 	currentTask.state.pause()
 }
 
+//export tinygo_pause
+func pause() {
+	Pause()
+}
+
 // Resume the task until it pauses or completes.
 // This may only be called from the scheduler.
 func (t *Task) Resume() {
@@ -58,10 +63,32 @@ func (s *state) initialize(fn uintptr, args unsafe.Pointer, stackSize uintptr) {
 	// Create a stack.
 	stack := make([]uintptr, stackSize/unsafe.Sizeof(uintptr(0)))
 
+	// Set up the stack canary, a random number that should be checked when
+	// switching from the task back to the scheduler. The stack canary pointer
+	// points to the first word of the stack. If it has changed between now and
+	// the next stack switch, there was a stack overflow.
+	s.canaryPtr = &stack[0]
+	*s.canaryPtr = stackCanary
+
+	// Get a pointer to the top of the stack, where the initial register values
+	// are stored. They will be popped off the stack on the first stack switch
+	// to the goroutine, and will start running tinygo_startTask (this setup
+	// happens in archInit).
+	r := (*calleeSavedRegs)(unsafe.Pointer(&stack[uintptr(len(stack))-(unsafe.Sizeof(calleeSavedRegs{})/unsafe.Sizeof(uintptr(0)))]))
+
 	// Invoke architecture-specific initialization.
-	s.archInit(stack, fn, args)
+	s.archInit(r, fn, args)
 }
 
+//export tinygo_swapTask
+func swapTask(oldStack uintptr, newStack *uintptr)
+
+// startTask is a small wrapper function that sets up the first (and only)
+// argument to the new goroutine and makes sure it is exited when the goroutine
+// finishes.
+//go:extern tinygo_startTask
+var startTask [0]uint8
+
 //go:linkname runqueuePushBack runtime.runqueuePushBack
 func runqueuePushBack(*Task)
 

src/internal/task/task_stack_avr.S

@@ -0,0 +1,99 @@
+.section .bss.tinygo_systemStack
+.global tinygo_systemStack
+.type   tinygo_systemStack, %object
+tinygo_systemStack:
+    .short 0
+
+.section .text.tinygo_startTask
+.global  tinygo_startTask
+.type    tinygo_startTask, %function
+tinygo_startTask:
+    // Small assembly stub for starting a goroutine. This is already run on the
+    // new stack, with the callee-saved registers already loaded.
+    // Most importantly, r2r3 contain the pc of the to-be-started function and
+    // r4r5 contain the only argument it is given. Multiple arguments are packed
+    // into one by storing them in a new allocation.
+
+    // Set the first argument of the goroutine start wrapper, which contains all
+    // the arguments.
+    movw  r24, r4
+
+    // Branch to the "goroutine start" function. Note that the Z register is
+    // call-clobbered, so does not need to be restored after use.
+    movw  Z, r2
+    icall
+
+    // After return, exit this goroutine. This is a tail call.
+#if __AVR_ARCH__ == 2 || __AVR_ARCH__ == 25
+    // Small memory devices (≤8kB flash) that do not have the long call
+    // instruction availble will need to use rcall instead.
+    // Note that they will probably not be able to run more than the main
+    // goroutine anyway, but this file is compiled for all AVRs so it needs to
+    // compile at least.
+    rcall  tinygo_pause
+#else
+    // Other devices can (and must) use the regular call instruction.
+    call tinygo_pause
+#endif
+
+.global tinygo_swapTask
+.type tinygo_swapTask, %function
+tinygo_swapTask:
+    // This function gets the following parameters:
+    // r24:r25 = newStack uintptr
+    // r22:r23 = oldStack *uintptr
+
+    // Save all call-saved registers:
+    // https://gcc.gnu.org/wiki/avr-gcc#Call-Saved_Registers
+    push r29 // Y
+    push r28 // Y
+    push r17
+    push r16
+    push r15
+    push r14
+    push r13
+    push r12
+    push r11
+    push r10
+    push r9
+    push r8
+    push r7
+    push r6
+    push r5
+    push r4
+    push r3
+    push r2
+
+    // Save the current stack pointer in oldStack.
+    in  r2, 0x3d; SPL
+    in  r3, 0x3e; SPH
+    movw Y, r22
+    std Y+0, r2
+    std Y+1, r3
+
+    // Switch to the new stack pointer.
+    out  0x3d, r24; SPL
+    out  0x3e, r25; SPH
+
+    // Load saved register from the new stack.
+    pop r2
+    pop r3
+    pop r4
+    pop r5
+    pop r6
+    pop r7
+    pop r8
+    pop r9
+    pop r10
+    pop r11
+    pop r12
+    pop r13
+    pop r14
+    pop r15
+    pop r16
+    pop r17
+    pop r28 // Y
+    pop r29 // Y
+
+    // Return into the new task, as if tinygo_swapTask was a regular call.
+    ret

src/internal/task/task_stack_avr.go

@@ -4,9 +4,12 @@ package task
 
 import "unsafe"
 
+//go:extern tinygo_systemStack
+var systemStack uintptr
+
 // calleeSavedRegs is the list of registers that must be saved and restored when
-// switching between tasks. Also see scheduler_avr.S that relies on the
-// exact layout of this struct.
+// switching between tasks. Also see task_stack_avr.S that relies on the exact
+// layout of this struct.
 //
 // https://gcc.gnu.org/wiki/avr-gcc#Call-Saved_Registers
 type calleeSavedRegs struct {
@@ -23,34 +26,15 @@ type calleeSavedRegs struct {
 	pc uintptr
 }
 
-// registers gets a pointer to the registers stored at the top of the stack.
-func (s *state) registers() *calleeSavedRegs {
-	return (*calleeSavedRegs)(unsafe.Pointer(s.sp + 1))
-}
-
-// startTask is a small wrapper function that sets up the first (and only)
-// argument to the new goroutine and makes sure it is exited when the goroutine
-// finishes.
-//go:extern tinygo_startTask
-var startTask [0]uint8
-
 // archInit runs architecture-specific setup for the goroutine startup.
 // Note: adding //go:noinline to work around an AVR backend bug.
 //go:noinline
-func (s *state) archInit(stack []uintptr, fn uintptr, args unsafe.Pointer) {
-	// Set up the stack canary, a random number that should be checked when
-	// switching from the task back to the scheduler. The stack canary pointer
-	// points to the first word of the stack. If it has changed between now and
-	// the next stack switch, there was a stack overflow.
-	s.canaryPtr = &stack[0]
-	*s.canaryPtr = stackCanary
-
+func (s *state) archInit(r *calleeSavedRegs, fn uintptr, args unsafe.Pointer) {
 	// Store the initial sp for the startTask function (implemented in assembly).
-	s.sp = uintptr(unsafe.Pointer(&stack[uintptr(len(stack))-(unsafe.Sizeof(calleeSavedRegs{})/unsafe.Sizeof(uintptr(0)))])) - 1
+	s.sp = uintptr(unsafe.Pointer(r)) - 1
 
 	// Initialize the registers.
 	// These will be popped off of the stack on the first resume of the goroutine.
-	r := s.registers()
 
 	// Start the function at tinygo_startTask.
 	startTask := uintptr(unsafe.Pointer(&startTask))
@@ -67,20 +51,17 @@ func (s *state) archInit(stack []uintptr, fn uintptr, args unsafe.Pointer) {
 }
 
 func (s *state) resume() {
-	switchToTask(s.sp)
+	swapTask(s.sp, &systemStack)
 }
 
-//export tinygo_switchToTask
-func switchToTask(uintptr)
-
-//export tinygo_switchToScheduler
-func switchToScheduler(*uintptr)
-
 func (s *state) pause() {
-	switchToScheduler(&s.sp)
+	newStack := systemStack
+	systemStack = 0
+	swapTask(newStack, &s.sp)
 }
 
-//export tinygo_pause
-func pause() {
-	Pause()
+// SystemStack returns the system stack pointer when called from a task stack.
+// When called from the system stack, it returns 0.
+func SystemStack() uintptr {
+	return systemStack
 }

src/internal/task/task_stack_cortexm.S

@@ -0,0 +1,127 @@
+// Only generate .debug_frame, don't generate .eh_frame.
+.cfi_sections .debug_frame
+
+.section .text.tinygo_startTask
+.global  tinygo_startTask
+.type    tinygo_startTask, %function
+tinygo_startTask:
+    .cfi_startproc
+    // Small assembly stub for starting a goroutine. This is already run on the
+    // new stack, with the callee-saved registers already loaded.
+    // Most importantly, r4 contains the pc of the to-be-started function and r5
+    // contains the only argument it is given. Multiple arguments are packed
+    // into one by storing them in a new allocation.
+
+    // Indicate to the unwinder that there is nothing to unwind, this is the
+    // root frame. It avoids the following (bogus) error message in GDB:
+    //     Backtrace stopped: previous frame identical to this frame (corrupt stack?)
+    .cfi_undefined lr
+
+    // Set the first argument of the goroutine start wrapper, which contains all
+    // the arguments.
+    mov   r0, r5
+
+    // Branch to the "goroutine start" function. By using blx instead of bx,
+    // we'll return here instead of tail calling.
+    blx   r4
+
+    // After return, exit this goroutine. This is a tail call.
+    bl    	tinygo_pause
+    .cfi_endproc
+.size tinygo_startTask, .-tinygo_startTask
+
+.section .text.tinygo_switchToScheduler
+.global  tinygo_switchToScheduler
+.type    tinygo_switchToScheduler, %function
+tinygo_switchToScheduler:
+    .cfi_startproc
+    // r0 = sp *uintptr
+
+    // Currently on the task stack (SP=PSP). We need to store the position on
+    // the stack where the in-use registers will be stored.
+    mov r1, sp
+    subs r1, #36
+    str r1, [r0]
+
+    b tinygo_swapTask
+    .cfi_endproc
+.size tinygo_switchToScheduler, .-tinygo_switchToScheduler
+
+.section .text.tinygo_switchToTask
+.global  tinygo_switchToTask
+.type    tinygo_switchToTask, %function
+tinygo_switchToTask:
+    .cfi_startproc
+    // r0 = sp uintptr
+
+    // Currently on the scheduler stack (SP=MSP). We'll have to update the PSP,
+    // and then we can invoke swapTask.
+    msr PSP, r0
+
+    b.n tinygo_swapTask
+    .cfi_endproc
+.size tinygo_switchToTask, .-tinygo_switchToTask
+
+.section .text.tinygo_swapTask
+.global  tinygo_swapTask
+.type    tinygo_swapTask, %function
+tinygo_swapTask:
+    .cfi_startproc
+    // This function stores the current register state to the stack, switches to
+    // the other stack (MSP/PSP), and loads the register state from the other
+    // stack. Apart from saving and restoring all relevant callee-saved
+    // registers, it also ends with branching to the last program counter (saved
+    // as the lr register, to follow the ARM calling convention).
+
+    // On pre-Thumb2 CPUs (Cortex-M0 in particular), registers r8-r15 cannot be
+    // used directly. Only very few operations work on them, such as mov. That's
+    // why the higher register values are first stored in the temporary register
+    // r3 when loading/storing them.
+    // It is possible to reduce the swapTask by two instructions (~2 cycles) on
+    // Cortex-M0 by reordering the layout of the pushed registers from {r4-r11,
+    // lr} to {r8-r11, r4-r8, lr}. However, that also requires a change on the
+    // Go side (depending on thumb1/thumb2!) and so is not really worth the
+    // complexity.
+
+    // Store state to old task. It saves the lr instead of the pc, because that
+    // will be the pc after returning back to the old task (in a different
+    // invocation of swapTask).
+    #if defined(__thumb2__)
+    push {r4-r11, lr}
+    .cfi_def_cfa_offset 9*4
+    #else
+    mov r0, r8
+    mov r1, r9
+    mov r2, r10
+    mov r3, r11
+    push {r0-r3, lr}
+    .cfi_def_cfa_offset 5*4
+    push {r4-r7}
+    .cfi_def_cfa_offset 9*4
+    #endif
+
+    // Switch the stack. This could either switch from PSP to MSP, or from MSP
+    // to PSP. By using an XOR (eor), it will just switch to the other stack.
+    mrs  r0, CONTROL // load CONTROL register
+    movs r3, #2
+    eors r0, r0, r3  // flip the SPSEL (active stack pointer) bit
+    msr  CONTROL, r0 // store CONTROL register
+    isb              // required to flush the pipeline
+
+    // Load state from new task and branch to the previous position in the
+    // program.
+    #if defined(__thumb2__)
+    pop {r4-r11, pc}
+    #else
+    pop {r4-r7}
+    .cfi_def_cfa_offset 5*9
+    pop {r0-r3}
+    .cfi_def_cfa_offset 1*9
+    mov r8, r0
+    mov r9, r1
+    mov r10, r2
+    mov r11, r3
+    pop {pc}
+    #endif
+    .cfi_endproc
+.size tinygo_swapTask, .-tinygo_swapTask

src/internal/task/task_stack_cortexm.go

@@ -2,10 +2,13 @@
 
 package task
 
-import "unsafe"
+import (
+	"device/arm"
+	"unsafe"
+)
 
 // calleeSavedRegs is the list of registers that must be saved and restored when
-// switching between tasks. Also see scheduler_cortexm.S that relies on the
+// switching between tasks. Also see task_stack_cortexm.S that relies on the
 // exact layout of this struct.
 type calleeSavedRegs struct {
 	r4  uintptr
@@ -20,34 +23,15 @@ type calleeSavedRegs struct {
 	pc uintptr
 }
 
-// registers gets a pointer to the registers stored at the top of the stack.
-func (s *state) registers() *calleeSavedRegs {
-	return (*calleeSavedRegs)(unsafe.Pointer(s.sp))
-}
-
-// startTask is a small wrapper function that sets up the first (and only)
-// argument to the new goroutine and makes sure it is exited when the goroutine
-// finishes.
-//go:extern tinygo_startTask
-var startTask [0]uint8
-
 // archInit runs architecture-specific setup for the goroutine startup.
-func (s *state) archInit(stack []uintptr, fn uintptr, args unsafe.Pointer) {
-	// Set up the stack canary, a random number that should be checked when
-	// switching from the task back to the scheduler. The stack canary pointer
-	// points to the first word of the stack. If it has changed between now and
-	// the next stack switch, there was a stack overflow.
-	s.canaryPtr = &stack[0]
-	*s.canaryPtr = stackCanary
-
+func (s *state) archInit(r *calleeSavedRegs, fn uintptr, args unsafe.Pointer) {
 	// Store the initial sp for the startTask function (implemented in assembly).
-	s.sp = uintptr(unsafe.Pointer(&stack[uintptr(len(stack))-(unsafe.Sizeof(calleeSavedRegs{})/unsafe.Sizeof(uintptr(0)))]))
+	s.sp = uintptr(unsafe.Pointer(r))
 
 	// Initialize the registers.
 	// These will be popped off of the stack on the first resume of the goroutine.
-	r := s.registers()
 
-	// Start the function at tinygo_startTask (defined in src/runtime/scheduler_cortexm.S).
+	// Start the function at tinygo_startTask (defined in src/internal/task/task_stack_cortexm.S).
 	// This assembly code calls a function (passed in r4) with a single argument (passed in r5).
 	// After the function returns, it calls Pause().
 	r.pc = uintptr(unsafe.Pointer(&startTask))
@@ -75,7 +59,8 @@ func (s *state) pause() {
 	switchToScheduler(&s.sp)
 }
 
-//export tinygo_pause
-func pause() {
-	Pause()
+// SystemStack returns the system stack pointer. On Cortex-M, it is always
+// available.
+func SystemStack() uintptr {
+	return arm.AsmFull("mrs {}, MSP", nil)
 }