mirror of
https://github.com/tinygo-org/tinygo.git
synced 2026-08-03 02:27:48 +00:00
Ayke van Laethem
098f900363
I have chosed to call this implementation `esp8266` instead of `xtensa` as it has been written specifically for the ESP8266 and there are no other Xtensa chips with the CALL0 ABI (no windowing) that I know of. The only other related chip is the ESP32, which does implement register windowing and thus needs a very different implementation.
71 lines
2.2 KiB
Go
71 lines
2.2 KiB
Go
// +build scheduler.tasks,esp8266
|
|
|
|
package task
|
|
|
|
// Stack switch implementation for the ESP8266, which does not use the windowed
|
|
// ABI of Xtensa. Registers are assigned as follows:
|
|
// a0: return address (link register)
|
|
// a1: stack pointer (must be 16-byte aligned)
|
|
// a2-a7: incoming arguments
|
|
// a8: static chain (unused)
|
|
// a12-a15: callee-saved
|
|
// a15: stack frame pointer (optional, unused)
|
|
// Sources:
|
|
// http://cholla.mmto.org/esp8266/xtensa.html
|
|
// https://0x04.net/~mwk/doc/xtensa.pdf
|
|
|
|
import "unsafe"
|
|
|
|
var systemStack uintptr
|
|
|
|
// calleeSavedRegs is the list of registers that must be saved and restored when
|
|
// switching between tasks. Also see task_stack_esp8266.S that relies on the
|
|
// exact layout of this struct.
|
|
type calleeSavedRegs struct {
|
|
a12 uintptr
|
|
a13 uintptr
|
|
a14 uintptr
|
|
a15 uintptr
|
|
|
|
pc uintptr // also link register or r0
|
|
}
|
|
|
|
// archInit runs architecture-specific setup for the goroutine startup.
|
|
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(r))
|
|
|
|
// Initialize the registers.
|
|
// These will be popped off of the stack on the first resume of the goroutine.
|
|
|
|
// Start the function at tinygo_startTask (defined in
|
|
// src/internal/task/task_stack_esp8266.S).
|
|
// This assembly code calls a function (passed in a12) with a single argument
|
|
// (passed in a13). After the function returns, it calls Pause().
|
|
r.pc = uintptr(unsafe.Pointer(&startTask))
|
|
|
|
// Pass the function to call in a12.
|
|
// This function is a compiler-generated wrapper which loads arguments out of a struct pointer.
|
|
// See createGoroutineStartWrapper (defined in compiler/goroutine.go) for more information.
|
|
r.a12 = fn
|
|
|
|
// Pass the pointer to the arguments struct in a13.
|
|
r.a13 = uintptr(args)
|
|
}
|
|
|
|
func (s *state) resume() {
|
|
swapTask(s.sp, &systemStack)
|
|
}
|
|
|
|
func (s *state) pause() {
|
|
newStack := systemStack
|
|
systemStack = 0
|
|
swapTask(newStack, &s.sp)
|
|
}
|
|
|
|
// 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
|
|
}
|