nintendoswitch: Add experimental Nintendo Switch support without CRT

	Bare minimal nintendo switch support using LLD

Author: racerxdl

Makefile

@@ -342,6 +342,8 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -opt=1     examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build             -o test.elf -target=nintendoswitch      examples/serial
+	@$(MD5SUM) test.elf
 
 wasmtest:
 	$(GO) test ./tests/wasm

compileopts/config.go

@@ -284,6 +284,16 @@ func (c *Config) CodeModel() string {
 	return "default"
 }
 
+// RelocationModel returns the relocation model in use on this platform. Valid
+// values are "static", "pic", "dynamicnopic".
+func (c *Config) RelocationModel() string {
+	if c.Target.RelocationModel != "" {
+		return c.Target.RelocationModel
+	}
+
+	return "static"
+}
+
 type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc

compileopts/target.go

@@ -50,6 +50,7 @@ type TargetSpec struct {
 	OpenOCDTransport string   `json:"openocd-transport"`
 	JLinkDevice      string   `json:"jlink-device"`
 	CodeModel        string   `json:"code-model"`
+	RelocationModel  string   `json:"relocation-model"`
 }
 
 // copyProperties copies all properties that are set in spec2 into itself.
@@ -134,6 +135,10 @@ func (spec *TargetSpec) copyProperties(spec2 *TargetSpec) {
 	if spec2.CodeModel != "" {
 		spec.CodeModel = spec2.CodeModel
 	}
+
+	if spec2.RelocationModel != "" {
+		spec.RelocationModel = spec2.RelocationModel
+	}
 }
 
 // load reads a target specification from the JSON in the given io.Reader. It

compiler/compiler.go

@@ -93,6 +93,7 @@ func NewTargetMachine(config *compileopts.Config) (llvm.TargetMachine, error) {
 	features := strings.Join(config.Features(), ",")
 
 	var codeModel llvm.CodeModel
+	var relocationModel llvm.RelocMode
 
 	switch config.CodeModel() {
 	case "default":
@@ -109,7 +110,16 @@ func NewTargetMachine(config *compileopts.Config) (llvm.TargetMachine, error) {
 		codeModel = llvm.CodeModelLarge
 	}
 
-	machine := target.CreateTargetMachine(config.Triple(), config.CPU(), features, llvm.CodeGenLevelDefault, llvm.RelocStatic, codeModel)
+	switch config.RelocationModel() {
+	case "static":
+		relocationModel = llvm.RelocStatic
+	case "pic":
+		relocationModel = llvm.RelocPIC
+	case "dynamicnopic":
+		relocationModel = llvm.RelocDynamicNoPic
+	}
+
+	machine := target.CreateTargetMachine(config.Triple(), config.CPU(), features, llvm.CodeGenLevelDefault, relocationModel, codeModel)
 	return machine, nil
 }
 

loader/goroot.go

@@ -165,7 +165,7 @@ func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides
 // with the TinyGo version. This is the case on some targets.
 func needsSyscallPackage(buildTags []string) bool {
 	for _, tag := range buildTags {
-		if tag == "baremetal" || tag == "darwin" {
+		if tag == "baremetal" || tag == "darwin" || tag == "nintendoswitch" {
 			return true
 		}
 	}

src/runtime/runtime_nintendoswitch.go

@@ -0,0 +1,73 @@
+// +build nintendoswitch
+
+package runtime
+
+type timeUnit int64
+
+const asyncScheduler = false
+
+func postinit() {}
+
+// Entry point for Go. Initialize all packages and call main.main().
+//export main
+func main() int {
+	preinit()
+	run()
+
+	// Call exit to correctly finish the program
+	// Without this, the application crashes at start, not sure why
+	return exit(0)
+}
+
+// sleepTicks sleeps for the specified system ticks
+func sleepTicks(d timeUnit) {
+	sleepThread(uint64(ticksToNanoseconds(d)))
+}
+
+// armTicksToNs converts cpu ticks to nanoseconds
+// Nintendo Switch CPU ticks has a fixed rate at 19200000
+// It is basically 52 ns per tick
+// The formula 625 / 12 is equivalent to 1e9 / 19200000
+func ticksToNanoseconds(tick timeUnit) int64 {
+	return int64(tick * 625 / 12)
+}
+
+func nanosecondsToTicks(ns int64) timeUnit {
+	return timeUnit(12 * ns / 625)
+}
+
+func ticks() timeUnit {
+	return timeUnit(ticksToNanoseconds(timeUnit(getArmSystemTick())))
+}
+
+var stdoutBuffer = make([]byte, 0, 120)
+
+func putchar(c byte) {
+	if c == '\n' || len(stdoutBuffer)+1 >= 120 {
+		NxOutputString(string(stdoutBuffer))
+		stdoutBuffer = stdoutBuffer[:0]
+		return
+	}
+
+	stdoutBuffer = append(stdoutBuffer, c)
+}
+
+func usleep(usec uint) int {
+	sleepThread(uint64(usec) * 1000)
+	return 0
+}
+
+func abort() {
+	for {
+		exit(1)
+	}
+}
+
+//export sleepThread
+func sleepThread(nanos uint64)
+
+//export exit
+func exit(code int) int
+
+//export armGetSystemTick
+func getArmSystemTick() int64

src/runtime/runtime_nintendoswitch.s

@@ -0,0 +1,45 @@
+.section .text.armGetSystemTick, "ax", %progbits
+.global  armGetSystemTick
+.type    armGetSystemTick, %function
+.align 2
+armGetSystemTick:
+    mrs x0, cntpct_el0
+    ret
+
+.section .text.nxOutputString, "ax", %progbits
+.global nxOutputString
+.type nxOutputString, %function
+.align 2
+.cfi_startproc
+nxOutputString:
+	svc 0x27
+	ret
+.cfi_endproc
+
+.section .text.exit, "ax", %progbits
+.global exit
+.type exit, %function
+.align 2
+exit:
+	svc 0x7
+	ret
+
+.section .text.setHeapSize, "ax", %progbits
+.global setHeapSize
+.type setHeapSize, %function
+.align 2
+setHeapSize:
+	str x0, [sp, #-16]!
+	svc 0x1
+	ldr x2, [sp], #16
+	str x1, [x2]
+	ret
+
+
+.section .text.sleepThread, "ax", %progbits
+.global sleepThread
+.type sleepThread, %function
+.align 2
+sleepThread:
+	svc 0xB
+	ret

src/runtime/runtime_nintendoswitch_heap.go

@@ -0,0 +1,31 @@
+// +build nintendoswitch
+
+// +build gc.conservative gc.leaking
+
+package runtime
+
+import "unsafe"
+
+const heapSize = 0x2000000 * 16 // Default by libnx
+
+//go:extern _stack_top
+var stackTopSymbol [0]byte
+
+var (
+	heapStart = uintptr(0)
+	heapEnd   = uintptr(0)
+	stackTop  = uintptr(unsafe.Pointer(&stackTopSymbol))
+)
+
+//export setHeapSize
+func setHeapSize(addr *uintptr, length uint64) uint64
+
+func preinit() {
+	setHeapSize(&heapStart, heapSize)
+
+	if heapStart == 0 {
+		panic("failed to allocate heap")
+	}
+
+	heapEnd = heapStart + heapSize
+}

src/runtime/runtime_nintendoswitch_noheap.go

@@ -0,0 +1,7 @@
+// +build nintendoswitch
+
+// +build gc.none gc.extalloc
+
+package runtime
+
+func preinit() {}

src/runtime/runtime_nintendoswitch_svc.go

@@ -0,0 +1,22 @@
+// +build nintendoswitch
+
+package runtime
+
+import (
+	"unsafe"
+)
+
+// Result nxOutputString(const char *str, u64 size)
+//export nxOutputString
+func nxOutputString(str *uint8, size uint64) uint64
+
+func NxOutputString(str string) uint64 {
+	strData := (*_string)(unsafe.Pointer(&str))
+	return nxOutputString((*uint8)(unsafe.Pointer(strData.ptr)), uint64(strData.length))
+}
+
+//export malloc
+func extalloc(size uintptr) unsafe.Pointer
+
+//export free
+func extfree(ptr unsafe.Pointer)