test: run tests for AVR

This runs the currently working compiler tests for AVR using simavr. I
picked the atmega1284p target as it seems like the most suitable one
(most importantly, with a lot of RAM) so that tests are less likely to
hit resource limitations.

One extra change this required is using a different implementation of
the runtime.abort() function. The new one is smaller and will prevent
interrupts from running on exit, which should at least in theory be
fine. This pattern is required as it signals to simavr the program is
finished.

Author: aykevl

.circleci/config.yml

@@ -277,7 +277,7 @@ commands:
             curl https://dl.google.com/go/go1.15.5.darwin-amd64.tar.gz -o go1.15.5.darwin-amd64.tar.gz
             sudo tar -C /usr/local -xzf go1.15.5.darwin-amd64.tar.gz
             ln -s /usr/local/go/bin/go /usr/local/bin/go
-            HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu
+            HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu simavr
       - install-xtensa-toolchain:
           variant: "macos"
       - restore_cache:

main_test.go

@@ -12,8 +12,10 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"testing"
@@ -22,12 +24,31 @@ import (
 	"github.com/tinygo-org/tinygo/builder"
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
+	"tinygo.org/x/go-llvm"
 )
 
 const TESTDATA = "testdata"
 
 var testTarget = flag.String("target", "", "override test target")
 
+// There are a lot of tests that don't yet pass on AVR, often because avr-libc
+// doesn't provide the required functions (for float64 for example).
+var skipOnAVR = map[string]struct{}{
+	"testdata/atomic.go":     {},
+	"testdata/cgo/":          {},
+	"testdata/channel.go":    {},
+	"testdata/coroutines.go": {},
+	"testdata/float.go":      {},
+	"testdata/gc.go":         {},
+	"testdata/interface.go":  {},
+	"testdata/map.go":        {},
+	"testdata/math.go":       {},
+	"testdata/print.go":      {},
+	"testdata/reflect.go":    {},
+	"testdata/stdlib.go":     {},
+	"testdata/structs.go":    {},
+}
+
 func TestCompiler(t *testing.T) {
 	matches, err := filepath.Glob(filepath.Join(TESTDATA, "*.go"))
 	if err != nil {
@@ -77,6 +98,19 @@ func TestCompiler(t *testing.T) {
 		})
 	}
 
+	if runtime.GOOS == "darwin" {
+		// Running AVR tests only on Darwin as it has an easily installed
+		// homebrew simavr package.
+		llvmMajorVersion, _ := strconv.ParseInt(strings.Split(llvm.Version, ".")[0], 10, 32)
+		if llvmMajorVersion >= 11 {
+			// The AVR backend in LLVM 11 has been significantly improved and is
+			// able to correctly compile a lot more tests than before.
+			t.Run("AVR", func(t *testing.T) {
+				runPlatTests("atmega1284p", matches, t)
+			})
+		}
+	}
+
 	if runtime.GOOS == "linux" {
 		t.Run("X86Linux", func(t *testing.T) {
 			runPlatTests("i386--linux-gnu", matches, t)
@@ -114,6 +148,13 @@ func runPlatTests(target string, matches []string, t *testing.T) {
 	for _, path := range matches {
 		path := path // redefine to avoid race condition
 
+		if target == "atmega1284p" {
+			if _, ok := skipOnAVR[path]; ok {
+				// Some tests don't work on AVR yet, so skip them.
+				continue
+			}
+		}
+
 		t.Run(filepath.Base(path), func(t *testing.T) {
 			t.Parallel()
 			runTest(path, target, t)
@@ -180,6 +221,7 @@ func runTest(path, target string, t *testing.T) {
 	runComplete := make(chan struct{})
 	var cmd *exec.Cmd
 	ranTooLong := false
+	var emulator = ""
 	if target == "" {
 		cmd = exec.Command(binary)
 	} else {
@@ -190,13 +232,19 @@ func runTest(path, target string, t *testing.T) {
 		if len(spec.Emulator) == 0 {
 			cmd = exec.Command(binary)
 		} else {
+			emulator = spec.Emulator[0]
 			args := append(spec.Emulator[1:], binary)
 			cmd = exec.Command(spec.Emulator[0], args...)
 		}
 	}
 	stdout := &bytes.Buffer{}
-	cmd.Stdout = stdout
-	cmd.Stderr = os.Stderr
+	if emulator == "simavr" {
+		cmd.Stdout = nil
+		cmd.Stderr = stdout
+	} else {
+		cmd.Stdout = stdout
+		cmd.Stderr = os.Stderr
+	}
 	err = cmd.Start()
 	if err != nil {
 		t.Fatal("failed to start:", err)
@@ -230,6 +278,13 @@ func runTest(path, target string, t *testing.T) {
 	actual := bytes.Replace(stdout.Bytes(), []byte{'\r', '\n'}, []byte{'\n'}, -1)
 	expected = bytes.Replace(expected, []byte{'\r', '\n'}, []byte{'\n'}, -1) // for Windows
 
+	if emulator == "simavr" {
+		// Munge the data a bit to remove escape characters and the two dots
+		// simavr likes to put at the end of each line.
+		actual = regexp.MustCompile("\x1b.*?m").ReplaceAll(actual, nil)
+		actual = regexp.MustCompile("\\.\\.\n").ReplaceAll(actual, []byte{'\n'})
+	}
+
 	// Check whether the command ran successfully.
 	fail := false
 	if err != nil {

src/runtime/runtime_avr.go

@@ -96,7 +96,13 @@ func ticks() timeUnit {
 }
 
 func abort() {
+	avr.Asm("cli")
 	for {
-		sleepWDT(WDT_PERIOD_2S)
+		// Sleeping with interrupts disabled will mean the MCU sleeps forever.
+		// To be extra sure, put it in a loop.
+		// This mechanism is used by simavr to detect a program exit, the
+		// emulator will stop when it detects a sleep instruction with
+		// interrupts disabled.
+		avr.Asm("sleep")
 	}
 }