all: add linux/mipsle support

This adds linux/mipsle (little endian Mips) support to TinyGo.

It also adds experimental linux/mips (big-endian) support. It doesn't
quite work yet, some parts of the standard library (like the reflect
package) currently seem to assume a little-endian system.

src/internal/task/task_stack_mipsx.S

@@ -0,0 +1,66 @@
+.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, s0 contains the pc of the to-be-started function and s1
+    // contains 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.
+    move  $a0, $s1
+
+    // Branch to the "goroutine start" function. Use jalr to write the return
+    // address to ra so we'll return here after the goroutine exits.
+    jalr  $s0
+    nop
+
+    // After return, exit this goroutine. This is a tail call.
+    j     tinygo_pause
+    nop
+
+.section .text.tinygo_swapTask
+.global  tinygo_swapTask
+.type    tinygo_swapTask, %function
+tinygo_swapTask:
+    // This function gets the following parameters:
+    //   a0 = newStack uintptr
+    //   a1 = oldStack *uintptr
+
+    // Push all callee-saved registers.
+    addiu $sp, $sp, -40
+    sw $ra, 36($sp)
+    sw $s8, 32($sp)
+    sw $s7, 28($sp)
+    sw $s6, 24($sp)
+    sw $s5, 20($sp)
+    sw $s4, 16($sp)
+    sw $s3, 12($sp)
+    sw $s2,  8($sp)
+    sw $s1,  4($sp)
+    sw $s0,   ($sp)
+
+    // Save the current stack pointer in oldStack.
+    sw $sp, 0($a1)
+
+    // Switch to the new stack pointer.
+    move $sp, $a0
+
+    // Pop all saved registers from this new stack.
+    lw $ra,  36($sp)
+    lw $s8,  32($sp)
+    lw $s7,  28($sp)
+    lw $s6,  24($sp)
+    lw $s5,  20($sp)
+    lw $s4,  16($sp)
+    lw $s3,  12($sp)
+    lw $s2,   8($sp)
+    lw $s1,   4($sp)
+    lw $s0,    ($sp)
+    addiu $sp, $sp, 40
+
+    // Return into the task.
+    jalr $ra
+    nop

src/internal/task/task_stack_mipsx.go

@@ -0,0 +1,61 @@
+//go:build scheduler.tasks && (mips || mipsle)
+
+package task
+
+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_mips.S that relies on the exact
+// layout of this struct.
+type calleeSavedRegs struct {
+	s0 uintptr
+	s1 uintptr
+	s2 uintptr
+	s3 uintptr
+	s4 uintptr
+	s5 uintptr
+	s6 uintptr
+	s7 uintptr
+	s8 uintptr
+	ra uintptr
+}
+
+// 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_mipsle.S).
+	// This assembly code calls a function (passed in s0) with a single argument
+	// (passed in s1). After the function returns, it calls Pause().
+	r.ra = uintptr(unsafe.Pointer(&startTask))
+
+	// Pass the function to call in s0.
+	// 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.s0 = fn
+
+	// Pass the pointer to the arguments struct in s1.
+	r.s1 = 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
+}

src/runtime/arch_386.go

@@ -9,6 +9,8 @@ const deferExtraRegs = 0
 
 const callInstSize = 5 // "call someFunction" is 5 bytes
 
+const linux_MAP_ANONYMOUS = 0x20
+
 // Align on word boundary.
 func align(ptr uintptr) uintptr {
 	return (ptr + 15) &^ 15

src/runtime/arch_amd64.go

@@ -9,6 +9,8 @@ const deferExtraRegs = 0
 
 const callInstSize = 5 // "call someFunction" is 5 bytes
 
+const linux_MAP_ANONYMOUS = 0x20
+
 // Align a pointer.
 // Note that some amd64 instructions (like movaps) expect 16-byte aligned
 // memory, thus the result must be 16-byte aligned.

src/runtime/arch_arm.go

@@ -11,6 +11,8 @@ const deferExtraRegs = 0
 
 const callInstSize = 4 // "bl someFunction" is 4 bytes
 
+const linux_MAP_ANONYMOUS = 0x20
+
 // Align on the maximum alignment for this platform (double).
 func align(ptr uintptr) uintptr {
 	return (ptr + 7) &^ 7

src/runtime/arch_arm64.go

@@ -9,6 +9,8 @@ const deferExtraRegs = 0
 
 const callInstSize = 4 // "bl someFunction" is 4 bytes
 
+const linux_MAP_ANONYMOUS = 0x20
+
 // Align on word boundary.
 func align(ptr uintptr) uintptr {
 	return (ptr + 15) &^ 15

src/runtime/arch_mips.go

@@ -0,0 +1,21 @@
+package runtime
+
+const GOARCH = "mips"
+
+// The bitness of the CPU (e.g. 8, 32, 64).
+const TargetBits = 32
+
+const deferExtraRegs = 0
+
+const callInstSize = 8 // "jal someFunc" is 4 bytes, plus a MIPS delay slot
+
+const linux_MAP_ANONYMOUS = 0x800
+
+// It appears that MIPS has a maximum alignment of 8 bytes.
+func align(ptr uintptr) uintptr {
+	return (ptr + 7) &^ 7
+}
+
+func getCurrentStackPointer() uintptr {
+	return uintptr(stacksave())
+}

src/runtime/arch_mipsle.go

@@ -0,0 +1,21 @@
+package runtime
+
+const GOARCH = "mipsle"
+
+// The bitness of the CPU (e.g. 8, 32, 64).
+const TargetBits = 32
+
+const deferExtraRegs = 0
+
+const callInstSize = 8 // "jal someFunc" is 4 bytes, plus a MIPS delay slot
+
+const linux_MAP_ANONYMOUS = 0x800
+
+// It appears that MIPS has a maximum alignment of 8 bytes.
+func align(ptr uintptr) uintptr {
+	return (ptr + 7) &^ 7
+}
+
+func getCurrentStackPointer() uintptr {
+	return uintptr(stacksave())
+}

src/runtime/asm_mipsx.S

@@ -0,0 +1,40 @@
+.section .text.tinygo_scanCurrentStack
+.global  tinygo_scanCurrentStack
+.type    tinygo_scanCurrentStack, %function
+tinygo_scanCurrentStack:
+    // Push callee-saved registers onto the stack.
+    addiu $sp, $sp, -40
+    sw $ra, 36($sp)
+    sw $s8, 32($sp)
+    sw $s7, 28($sp)
+    sw $s6, 24($sp)
+    sw $s5, 20($sp)
+    sw $s4, 16($sp)
+    sw $s3, 12($sp)
+    sw $s2,  8($sp)
+    sw $s1,  4($sp)
+    sw $s0,   ($sp)
+
+    // Scan the stack.
+    jal tinygo_scanstack
+    move $a0, $sp // in the branch delay slot
+
+    // Restore return address.
+    lw $ra, 36($sp)
+
+    // Restore stack state.
+    addiu $sp, $sp, 40
+
+    // Return to the caller.
+    jalr $ra
+    nop
+
+.section .text.tinygo_longjmp
+.global tinygo_longjmp
+tinygo_longjmp:
+    // Note: the code we jump to assumes a0 is non-zero, which is already the
+    // case because that's the defer frame pointer.
+    lw $sp, 0($a0) // jumpSP
+    lw $a1, 4($a0) // jumpPC
+    jr $a1
+    nop

src/runtime/os_linux.go

@@ -14,7 +14,7 @@ const (
 	flag_PROT_READ     = 0x1
 	flag_PROT_WRITE    = 0x2
 	flag_MAP_PRIVATE   = 0x2
-	flag_MAP_ANONYMOUS = 0x20
+	flag_MAP_ANONYMOUS = linux_MAP_ANONYMOUS // different on alpha, hppa, mips, xtensa
 )
 
 // Source: https://github.com/torvalds/linux/blob/master/include/uapi/linux/time.h

src/runtime/runtime_unix.go

@@ -229,6 +229,9 @@ func preinit() {
 			// heap size.
 			// This can happen on 32-bit systems.
 			heapMaxSize /= 2
+			if heapMaxSize < 4096 {
+				runtimePanic("cannot allocate heap memory")
+			}
 			continue
 		}
 		heapStart = uintptr(addr)