interp: do not rely on fixed type names

After merging multiple LLVM modules into one, types may have been
renamed. Therefore, the interp package should not rely on types to have
any particular name.

.circleci/config.yml

@@ -37,13 +37,6 @@ commands:
             sudo tar -C /usr/local -xf node-v10.15.1-linux-x64.tar.xz
             sudo ln -s /usr/local/node-v10.15.1-linux-x64/bin/node /usr/bin/node
             rm node-v10.15.1-linux-x64.tar.xz
-  install-chrome:
-    steps:
-      - run:
-          name: "Install Chrome"
-          command: |
-            wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
-            sudo apt install ./google-chrome-stable_current_amd64.deb
   llvm-source-linux:
     steps:
       - restore_cache:
@@ -78,7 +71,6 @@ commands:
       - apt-dependencies:
           llvm: "<<parameters.llvm>>"
       - install-node
-      - install-chrome
       - restore_cache:
           keys:
             - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
@@ -93,11 +85,9 @@ commands:
           key: wasi-libc-sysroot-systemclang-v1
           paths:
             - lib/wasi-libc/sysroot
-      - run: tinygo clean
-      - run: go test -v -tags=llvm<<parameters.llvm>> ./cgo ./compileopts ./interp ./transform .
+      - run: go test -v -tags=llvm<<parameters.llvm>> ./cgo ./compileopts ./compiler ./interp ./transform .
       - run: make gen-device -j4
       - run: make smoketest
-      - run: make wasmtest
       - save_cache:
           key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
           paths:
@@ -214,21 +204,13 @@ commands:
       - run:
           name: "Test TinyGo"
           command: make test
-      - run:
-          name: "Install fpm"
-          command: |
-            sudo apt-get install ruby ruby-dev
-            sudo gem install --no-document fpm
       - run:
           name: "Build TinyGo release"
           command: |
-            make release deb -j3
+            make release -j3
             cp -p build/release.tar.gz /tmp/tinygo.linux-amd64.tar.gz
-            cp -p build/release.deb    /tmp/tinygo_amd64.deb
       - store_artifacts:
           path: /tmp/tinygo.linux-amd64.tar.gz
-      - store_artifacts:
-          path: /tmp/tinygo_amd64.deb
       - save_cache:
           key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
           paths:
@@ -312,6 +294,11 @@ commands:
             tar -C /usr/local/opt -xf /tmp/tinygo.darwin-amd64.tar.gz
             ln -s /usr/local/opt/tinygo/bin/tinygo /usr/local/bin/tinygo
             tinygo version
+      - run:
+          name: "Download SiFive GNU toolchain"
+          command: |
+            curl -O https://static.dev.sifive.com/dev-tools/riscv64-unknown-elf-gcc-8.2.0-2019.05.3-x86_64-apple-darwin.tar.gz
+            sudo tar -C /usr/local --strip-components=1 -xf riscv64-unknown-elf-gcc-8.2.0-2019.05.3-x86_64-apple-darwin.tar.gz
       - run: make smoketest AVR=0
       - save_cache:
           key: go-cache-macos-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}

Dockerfile

@@ -4,7 +4,7 @@ FROM golang:1.14 AS tinygo-base
 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
     echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main" >> /etc/apt/sources.list && \
     apt-get update && \
-    apt-get install -y llvm-10-dev libclang-10-dev lld-10 git
+    apt-get install -y llvm-10-dev libclang-10-dev git
 
 COPY . /tinygo
 
@@ -27,7 +27,10 @@ COPY --from=tinygo-base /go/bin/tinygo /go/bin/tinygo
 COPY --from=tinygo-base /tinygo/src /tinygo/src
 COPY --from=tinygo-base /tinygo/targets /tinygo/targets
 
-RUN apt-get install -y libllvm10 lld-10
+RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main" >> /etc/apt/sources.list && \
+    apt-get update && \
+    apt-get install -y libllvm10 lld-10
 
 # tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
 FROM tinygo-base AS tinygo-avr

Makefile

@@ -111,7 +111,7 @@ endif
 clean:
 	@rm -rf build
 
-FMT_PATHS = ./*.go builder cgo compiler interp ir loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/internal/reflectlite transform
+FMT_PATHS = ./*.go builder cgo compiler compiler/testdata interp loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/internal/reflectlite transform
 fmt:
 	@gofmt -l -w $(FMT_PATHS)
 fmt-check:
@@ -174,7 +174,7 @@ tinygo:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -o build/tinygo$(EXE) -tags byollvm .
 
 test: wasi-libc
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -tags byollvm ./cgo ./compileopts ./interp ./transform .
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -tags byollvm ./cgo ./compileopts ./compiler ./interp ./transform .
 
 tinygo-test:
 	cd tests/tinygotest && tinygo test
@@ -182,7 +182,7 @@ tinygo-test:
 .PHONY: smoketest
 smoketest:
 	$(TINYGO) version
-	# test all examples (except pwm)
+	# test all examples
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/adc
@@ -203,7 +203,7 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=microbit            examples/microbit-blink
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/pininterrupt
+	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/pwm
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/serial
 	@$(MD5SUM) test.hex
@@ -231,8 +231,6 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=microbit            examples/echo
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=microbit-s110v8     examples/echo
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=nrf52840-mdk        examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10031            examples/blinky1
@@ -293,18 +291,11 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=reelboard-s140v7    examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=wioterminal         examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pygamer             examples/blinky1
-	$(TINYGO) build -size short -o test.hex -target=xiao                examples/blinky1
-	@$(MD5SUM) test.hex
 ifneq ($(AVR), 0)
 	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino             examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino             examples/pwm
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino -scheduler=tasks  examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino-nano        examples/blinky1
@@ -319,10 +310,7 @@ endif
 	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/export
 	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/main
 
-wasmtest:
-	$(GO) test ./tests/wasm
-
-build/release: tinygo gen-device wasi-libc
+release: tinygo gen-device wasi-libc
 	@mkdir -p build/release/tinygo/bin
 	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
@@ -357,13 +345,4 @@ build/release: tinygo gen-device wasi-libc
 	./build/tinygo build-library -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/picolibc.a picolibc
 	./build/tinygo build-library -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/picolibc.a picolibc
 	./build/tinygo build-library -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/picolibc.a picolibc
-
-release: build/release
 	tar -czf build/release.tar.gz -C build/release tinygo
-
-deb: build/release
-	@mkdir -p build/release-deb/usr/local/bin
-	@mkdir -p build/release-deb/usr/local/lib
-	cp -ar build/release/tinygo build/release-deb/usr/local/lib/tinygo
-	ln -sf ../lib/tinygo/bin/tinygo build/release-deb/usr/local/bin/tinygo
-	fpm -f -s dir -t deb -n tinygo -v $(shell grep "const Version = " goenv/version.go | awk '{print $$NF}') -m '@tinygo-org' --description='TinyGo is a Go compiler for small places.' --license='BSD 3-Clause' --url=https://tinygo.org/ --deb-changelog CHANGELOG.md -p build/release.deb -C ./build/release-deb

README.md

@@ -43,7 +43,7 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for
 
 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.
 
-The following 34 microcontroller boards are currently supported:
+The following 32 microcontroller boards are currently supported:
 
 * [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333)
 * [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)
@@ -72,8 +72,6 @@ The following 34 microcontroller boards are currently supported:
 * [Particle Xenon](https://docs.particle.io/datasheets/discontinued/xenon-datasheet/)
 * [Phytec reel board](https://www.phytec.eu/product-eu/internet-of-things/reelboard/)
 * [PineTime DevKit](https://www.pine64.org/pinetime/)
-* [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html)
-* [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
 * [SiFIve HiFive1](https://www.sifive.com/boards/hifive1)
 * [ST Micro "Nucleo F103RB"](https://www.st.com/en/evaluation-tools/nucleo-f103rb.html)
 * [ST Micro STM32F103XX "Bluepill"](http://wiki.stm32duino.com/index.php?title=Blue_Pill)

azure-pipelines.yml

@@ -69,7 +69,7 @@ jobs:
         script: |
           export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
           unset GOROOT
-          make build/release -j4
+          make release -j4
     - publish: $(System.DefaultWorkingDirectory)/build/release/tinygo
       displayName: Publish zip as artifact
       artifact: tinygo

builder/build.go

@@ -32,7 +32,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 	if err != nil {
 		return err
 	}
-	mod, extraFiles, extraLDFlags, errs := compiler.Compile(pkgName, machine, config)
+	mod, extraFiles, errs := compiler.Compile(pkgName, machine, config)
 	if errs != nil {
 		return newMultiError(errs)
 	}
@@ -187,10 +187,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(stri
 			ldflags = append(ldflags, outpath)
 		}
 
-		if len(extraLDFlags) > 0 {
-			ldflags = append(ldflags, extraLDFlags...)
-		}
-
 		// Link the object files together.
 		err = link(config.Target.Linker, ldflags...)
 		if err != nil {

builder/builtins.go

@@ -16,10 +16,8 @@ var genericBuiltins = []string{
 	"addvsi3.c",
 	"addvti3.c",
 	"apple_versioning.c",
-	"ashlsi3.c",
 	"ashldi3.c",
 	"ashlti3.c",
-	"ashrsi3.c",
 	"ashrdi3.c",
 	"ashrti3.c",
 	"bswapdi2.c",
@@ -74,9 +72,7 @@ var genericBuiltins = []string{
 	"floatunsisf.c",
 	"floatuntidf.c",
 	"floatuntisf.c",
-	"fp_mode.c",
-	"int_util.c",
-	"lshrsi3.c",
+	//"int_util.c",
 	"lshrdi3.c",
 	"lshrti3.c",
 	"moddi3.c",
@@ -90,7 +86,6 @@ var genericBuiltins = []string{
 	"muloti4.c",
 	"mulsc3.c",
 	"mulsf3.c",
-	"mulsi3.c",
 	"multi3.c",
 	"multf3.c",
 	"mulvdi3.c",
@@ -113,7 +108,6 @@ var genericBuiltins = []string{
 	"powidf2.c",
 	"powisf2.c",
 	"powitf2.c",
-	"powixf2.c",
 	"subdf3.c",
 	"subsf3.c",
 	"subvdi3.c",
@@ -165,7 +159,7 @@ var aeabiBuiltins = []string{
 var CompilerRT = Library{
 	name:      "compiler-rt",
 	cflags:    func() []string { return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"} },
-	sourceDir: "llvm-project.master/compiler-rt/lib/builtins",
+	sourceDir: "lib/compiler-rt/lib/builtins",
 	sources: func(target string) []string {
 		builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
 		if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {

builder/config.go

@@ -21,7 +21,7 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	if goroot == "" {
 		return nil, errors.New("cannot locate $GOROOT, please set it manually")
 	}
-	major, minor, err := goenv.GetGorootVersion(goroot)
+	major, minor, err := getGorootVersion(goroot)
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}

builder/env.go

@@ -1,13 +1,71 @@
 package builder
 
 import (
+	"errors"
+	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"sort"
+	"strings"
 )
 
+// getGorootVersion returns the major and minor version for a given GOROOT path.
+// If the goroot cannot be determined, (0, 0) is returned.
+func getGorootVersion(goroot string) (major, minor int, err error) {
+	s, err := GorootVersionString(goroot)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	if s == "" || s[:2] != "go" {
+		return 0, 0, errors.New("could not parse Go version: version does not start with 'go' prefix")
+	}
+
+	parts := strings.Split(s[2:], ".")
+	if len(parts) < 2 {
+		return 0, 0, errors.New("could not parse Go version: version has less than two parts")
+	}
+
+	// Ignore the errors, we don't really handle errors here anyway.
+	var trailing string
+	n, err := fmt.Sscanf(s, "go%d.%d%s", &major, &minor, &trailing)
+	if n == 2 && err == io.EOF {
+		// Means there were no trailing characters (i.e., not an alpha/beta)
+		err = nil
+	}
+	if err != nil {
+		return 0, 0, fmt.Errorf("failed to parse version: %s", err)
+	}
+	return
+}
+
+// GorootVersionString returns the version string as reported by the Go
+// toolchain for the given GOROOT path. It is usually of the form `go1.x.y` but
+// can have some variations (for beta releases, for example).
+func GorootVersionString(goroot string) (string, error) {
+	if data, err := ioutil.ReadFile(filepath.Join(
+		goroot, "src", "runtime", "internal", "sys", "zversion.go")); err == nil {
+
+		r := regexp.MustCompile("const TheVersion = `(.*)`")
+		matches := r.FindSubmatch(data)
+		if len(matches) != 2 {
+			return "", errors.New("Invalid go version output:\n" + string(data))
+		}
+
+		return string(matches[1]), nil
+
+	} else if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
+		return string(data), nil
+
+	} else {
+		return "", err
+	}
+}
+
 // getClangHeaderPath returns the path to the built-in Clang headers. It tries
 // multiple locations, which should make it find the directory when installed in
 // various ways.

builder/library.go

@@ -69,14 +69,11 @@ func (l *Library) Load(target string) (path string, err error) {
 	// Precalculate the flags to the compiler invocation.
 	args := append(l.cflags(), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
 	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
-		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft")
+		args = append(args, "-fshort-enums", "-fomit-frame-pointer")
 	}
 	if strings.HasPrefix(target, "riscv32-") {
 		args = append(args, "-march=rv32imac", "-mabi=ilp32", "-fforce-enable-int128")
 	}
-	if strings.HasPrefix(target, "avr-") {
-		args = append(args, "-mdouble=64", "-mmcu=atmega1284p")
-	}
 
 	// Compile all sources.
 	var objs []string

builder/objcopy.go

@@ -123,7 +123,8 @@ func objcopy(infile, outfile string) error {
 		if err != nil {
 			return objcopyError{"failed to create .hex file", err}
 		}
-		return mem.DumpIntelHex(f, 16)
+		mem.DumpIntelHex(f, 16) // TODO: handle error
+		return nil
 	default:
 		panic("unreachable")
 	}

cgo/cgo.go

@@ -41,7 +41,6 @@ type cgoPackage struct {
 	elaboratedTypes map[string]*elaboratedTypeInfo
 	enums           map[string]enumInfo
 	anonStructNum   int
-	ldflags         []string
 }
 
 // constantInfo stores some information about a CGo constant found by libclang
@@ -157,7 +156,7 @@ typedef unsigned long long  _Cgo_ulonglong;
 // newly created *ast.File that should be added to the list of to-be-parsed
 // files. If there is one or more error, it returns these in the []error slice
 // but still modifies the AST.
-func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []string, []error) {
+func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []error) {
 	p := &cgoPackage{
 		dir:             dir,
 		fset:            fset,
@@ -184,7 +183,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	// Find the absolute path for this package.
 	packagePath, err := filepath.Abs(fset.File(files[0].Pos()).Name())
 	if err != nil {
-		return nil, nil, []error{
+		return nil, []error{
 			scanner.Error{
 				Pos: fset.Position(files[0].Pos()),
 				Msg: "cgo: cannot find absolute path: " + err.Error(), // TODO: wrap this error
@@ -360,19 +359,6 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 					}
 					makePathsAbsolute(flags, packagePath)
 					cflags = append(cflags, flags...)
-				case "LDFLAGS":
-					flags, err := shlex.Split(value)
-					if err != nil {
-						// TODO: find the exact location where the error happened.
-						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
-						continue
-					}
-					if err := checkLinkerFlags(name, flags); err != nil {
-						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
-						continue
-					}
-					makePathsAbsolute(flags, packagePath)
-					p.ldflags = append(p.ldflags, flags...)
 				default:
 					startPos := strings.LastIndex(line[4:colon], name) + 4
 					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+startPos], "invalid #cgo line: "+name)
@@ -426,7 +412,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	// Print the newly generated in-memory AST, for debugging.
 	//ast.Print(fset, p.generated)
 
-	return p.generated, p.ldflags, p.errors
+	return p.generated, p.errors
 }
 
 // makePathsAbsolute converts some common path compiler flags (-I, -L) from

cgo/cgo_test.go

@@ -50,7 +50,7 @@ func TestCGo(t *testing.T) {
 			}
 
 			// Process the AST with CGo.
-			cgoAST, _, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)
+			cgoAST, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)
 
 			// Check the AST for type errors.
 			var typecheckErrors []error

cgo/libclang.go

@@ -246,9 +246,9 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 		}
 		value := source[len(name):]
 		// Try to convert this #define into a Go constant expression.
-		expr, scannerError := parseConst(pos+token.Pos(len(name)), p.fset, value)
-		if scannerError != nil {
-			p.errors = append(p.errors, *scannerError)
+		expr, err := parseConst(pos+token.Pos(len(name)), p.fset, value)
+		if err != nil {
+			p.errors = append(p.errors, err)
 		}
 		if expr != nil {
 			// Parsing was successful.

cgo/libclang_config.go

@@ -1,5 +1,5 @@
 // +build !byollvm
-// +build !llvm9,!llvm11
+// +build !llvm9
 
 package cgo
 

cgo/libclang_config_llvm11.go

@@ -1,14 +0,0 @@
-// +build !byollvm
-// +build llvm11
-
-package cgo
-
-/*
-#cgo linux   CFLAGS:  -I/usr/lib/llvm-11/include
-#cgo darwin  CFLAGS:  -I/usr/local/opt/llvm@11/include
-#cgo freebsd CFLAGS:  -I/usr/local/llvm11/include
-#cgo linux   LDFLAGS: -L/usr/lib/llvm-11/lib -lclang
-#cgo darwin  LDFLAGS: -L/usr/local/opt/llvm@11/lib -lclang -lffi
-#cgo freebsd LDFLAGS: -L/usr/local/llvm11/lib -lclang
-*/
-import "C"

cgo/testdata/flags.go

@@ -21,13 +21,6 @@ package main
 #if defined(NOTDEFINED)
 #warning flag must not be defined
 #endif
-
-// Check Compiler flags
-#cgo LDFLAGS: -lc
-
-// This flag is not valid ldflags
-#cgo LDFLAGS: -does-not-exists
-
 */
 import "C"
 

cgo/testdata/flags.out.go

@@ -1,7 +1,6 @@
 // CGo errors:
 //     testdata/flags.go:5:7: invalid #cgo line: NOFLAGS
 //     testdata/flags.go:8:13: invalid flag: -fdoes-not-exist
-//     testdata/flags.go:29:14: invalid flag: -does-not-exists
 
 package main
 

compileopts/config.go

@@ -129,8 +129,8 @@ func (c *Config) NeedsStackObjects() bool {
 	}
 }
 
-// Scheduler returns the scheduler implementation. Valid values are "none",
-//"coroutines" and "tasks".
+// Scheduler returns the scheduler implementation. Valid values are "coroutines"
+// and "tasks".
 func (c *Config) Scheduler() string {
 	if c.Options.Scheduler != "" {
 		return c.Options.Scheduler
@@ -272,15 +272,6 @@ func (c *Config) OpenOCDConfiguration() (args []string, err error) {
 	return args, nil
 }
 
-// CodeModel returns the code model used on this platform.
-func (c *Config) CodeModel() string {
-	if c.Target.CodeModel != "" {
-		return c.Target.CodeModel
-	}
-
-	return "default"
-}
-
 type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc

compileopts/options.go

@@ -1,17 +1,5 @@
 package compileopts
 
-import (
-	"fmt"
-	"strings"
-)
-
-var (
-	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
-	validSchedulerOptions     = []string{"none", "tasks", "coroutines"}
-	validPrintSizeOptions     = []string{"none", "short", "full"}
-	validPanicStrategyOptions = []string{"print", "trap"}
-)
-
 // Options contains extra options to give to the compiler. These options are
 // usually passed from the command line.
 type Options struct {
@@ -33,53 +21,3 @@ type Options struct {
 	TestConfig    TestConfig
 	Programmer    string
 }
-
-// Verify performs a validation on the given options, raising an error if options are not valid.
-func (o *Options) Verify() error {
-	if o.GC != "" {
-		valid := isInArray(validGCOptions, o.GC)
-		if !valid {
-			return fmt.Errorf(`invalid gc option '%s': valid values are %s`,
-				o.GC,
-				strings.Join(validGCOptions, ", "))
-		}
-	}
-
-	if o.Scheduler != "" {
-		valid := isInArray(validSchedulerOptions, o.Scheduler)
-		if !valid {
-			return fmt.Errorf(`invalid scheduler option '%s': valid values are %s`,
-				o.Scheduler,
-				strings.Join(validSchedulerOptions, ", "))
-		}
-	}
-
-	if o.PrintSizes != "" {
-		valid := isInArray(validPrintSizeOptions, o.PrintSizes)
-		if !valid {
-			return fmt.Errorf(`invalid size option '%s': valid values are %s`,
-				o.PrintSizes,
-				strings.Join(validPrintSizeOptions, ", "))
-		}
-	}
-
-	if o.PanicStrategy != "" {
-		valid := isInArray(validPanicStrategyOptions, o.PanicStrategy)
-		if !valid {
-			return fmt.Errorf(`invalid panic option '%s': valid values are %s`,
-				o.PanicStrategy,
-				strings.Join(validPanicStrategyOptions, ", "))
-		}
-	}
-
-	return nil
-}
-
-func isInArray(arr []string, item string) bool {
-	for _, i := range arr {
-		if i == item {
-			return true
-		}
-	}
-	return false
-}

compileopts/options_test.go

@@ -1,138 +0,0 @@
-package compileopts_test
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/tinygo-org/tinygo/compileopts"
-)
-
-func TestVerifyOptions(t *testing.T) {
-
-	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, extalloc, conservative`)
-	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, coroutines`)
-	expectedPrintSizeError := errors.New(`invalid size option 'incorrect': valid values are none, short, full`)
-	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)
-
-	testCases := []struct {
-		name          string
-		opts          compileopts.Options
-		expectedError error
-	}{
-		{
-			name: "OptionsEmpty",
-			opts: compileopts.Options{},
-		},
-		{
-			name: "InvalidGCOption",
-			opts: compileopts.Options{
-				GC: "incorrect",
-			},
-			expectedError: expectedGCError,
-		},
-		{
-			name: "GCOptionNone",
-			opts: compileopts.Options{
-				GC: "none",
-			},
-		},
-		{
-			name: "GCOptionLeaking",
-			opts: compileopts.Options{
-				GC: "leaking",
-			},
-		},
-		{
-			name: "GCOptionExtalloc",
-			opts: compileopts.Options{
-				GC: "extalloc",
-			},
-		},
-		{
-			name: "GCOptionConservative",
-			opts: compileopts.Options{
-				GC: "conservative",
-			},
-		},
-		{
-			name: "InvalidSchedulerOption",
-			opts: compileopts.Options{
-				Scheduler: "incorrect",
-			},
-			expectedError: expectedSchedulerError,
-		},
-		{
-			name: "SchedulerOptionNone",
-			opts: compileopts.Options{
-				Scheduler: "none",
-			},
-		},
-		{
-			name: "SchedulerOptionTasks",
-			opts: compileopts.Options{
-				Scheduler: "tasks",
-			},
-		},
-		{
-			name: "SchedulerOptionCoroutines",
-			opts: compileopts.Options{
-				Scheduler: "coroutines",
-			},
-		},
-		{
-			name: "InvalidPrintSizeOption",
-			opts: compileopts.Options{
-				PrintSizes: "incorrect",
-			},
-			expectedError: expectedPrintSizeError,
-		},
-		{
-			name: "PrintSizeOptionNone",
-			opts: compileopts.Options{
-				PrintSizes: "none",
-			},
-		},
-		{
-			name: "PrintSizeOptionShort",
-			opts: compileopts.Options{
-				PrintSizes: "short",
-			},
-		},
-		{
-			name: "PrintSizeOptionFull",
-			opts: compileopts.Options{
-				PrintSizes: "full",
-			},
-		},
-		{
-			name: "InvalidPanicOption",
-			opts: compileopts.Options{
-				PanicStrategy: "incorrect",
-			},
-			expectedError: expectedPanicStrategyError,
-		},
-		{
-			name: "PanicOptionPrint",
-			opts: compileopts.Options{
-				PanicStrategy: "print",
-			},
-		},
-		{
-			name: "PanicOptionTrap",
-			opts: compileopts.Options{
-				PanicStrategy: "trap",
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			err := tc.opts.Verify()
-			if tc.expectedError != err {
-				if tc.expectedError.Error() != err.Error() {
-					t.Errorf("expected %v, got %v", tc.expectedError, err)
-				}
-			}
-		})
-	}
-}

compileopts/target.go

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

compiler/asserts.go

@@ -16,7 +16,7 @@ import (
 // slice. This is required by the Go language spec: an index out of bounds must
 // cause a panic.
 func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType types.Type) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -48,7 +48,7 @@ func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType
 // biggest possible slice capacity, 'low' means len and 'high' means cap. The
 // logic is the same in both cases.
 func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lowType, highType, maxType *types.Basic) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -104,7 +104,7 @@ func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lo
 // createChanBoundsCheck creates a bounds check before creating a new channel to
 // check that the value is not too big for runtime.chanMake.
 func (b *builder) createChanBoundsCheck(elementSize uint64, bufSize llvm.Value, bufSizeType *types.Basic, pos token.Pos) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -189,7 +189,7 @@ func (b *builder) createNilCheck(inst ssa.Value, ptr llvm.Value, blockPrefix str
 // createNegativeShiftCheck creates an assertion that panics if the given shift value is negative.
 // This function assumes that the shift value is signed.
 func (b *builder) createNegativeShiftCheck(shift llvm.Value) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// Function disabled bounds checking - skip shift check.
 		return
 	}
@@ -212,8 +212,8 @@ func (b *builder) createRuntimeAssert(assert llvm.Value, blockPrefix, assertFunc
 		}
 	}
 
-	faultBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, blockPrefix+".throw")
-	nextBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, blockPrefix+".next")
+	faultBlock := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".throw")
+	nextBlock := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".next")
 	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
 
 	// Now branch to the out-of-bounds or the regular block.

compiler/atomic.go

@@ -1,57 +0,0 @@
-package compiler
-
-import (
-	"golang.org/x/tools/go/ssa"
-	"tinygo.org/x/go-llvm"
-)
-
-// createAtomicOp lowers an atomic library call by lowering it as an LLVM atomic
-// operation. It returns the result of the operation and true if the call could
-// be lowered inline, and false otherwise.
-func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
-	name := call.Value.(*ssa.Function).Name()
-	switch name {
-	case "AddInt32", "AddInt64", "AddUint32", "AddUint64", "AddUintptr":
-		ptr := b.getValue(call.Args[0])
-		val := b.getValue(call.Args[1])
-		oldVal := b.CreateAtomicRMW(llvm.AtomicRMWBinOpAdd, ptr, val, llvm.AtomicOrderingSequentiallyConsistent, true)
-		// Return the new value, not the original value returned by atomicrmw.
-		return b.CreateAdd(oldVal, val, ""), true
-	case "SwapInt32", "SwapInt64", "SwapUint32", "SwapUint64", "SwapUintptr", "SwapPointer":
-		ptr := b.getValue(call.Args[0])
-		val := b.getValue(call.Args[1])
-		isPointer := val.Type().TypeKind() == llvm.PointerTypeKind
-		if isPointer {
-			// atomicrmw only supports integers, so cast to an integer.
-			val = b.CreatePtrToInt(val, b.uintptrType, "")
-			ptr = b.CreateBitCast(ptr, llvm.PointerType(val.Type(), 0), "")
-		}
-		oldVal := b.CreateAtomicRMW(llvm.AtomicRMWBinOpXchg, ptr, val, llvm.AtomicOrderingSequentiallyConsistent, true)
-		if isPointer {
-			oldVal = b.CreateIntToPtr(oldVal, b.i8ptrType, "")
-		}
-		return oldVal, true
-	case "CompareAndSwapInt32", "CompareAndSwapInt64", "CompareAndSwapUint32", "CompareAndSwapUint64", "CompareAndSwapUintptr", "CompareAndSwapPointer":
-		ptr := b.getValue(call.Args[0])
-		old := b.getValue(call.Args[1])
-		newVal := b.getValue(call.Args[2])
-		tuple := b.CreateAtomicCmpXchg(ptr, old, newVal, llvm.AtomicOrderingSequentiallyConsistent, llvm.AtomicOrderingSequentiallyConsistent, true)
-		swapped := b.CreateExtractValue(tuple, 1, "")
-		return swapped, true
-	case "LoadInt32", "LoadInt64", "LoadUint32", "LoadUint64", "LoadUintptr", "LoadPointer":
-		ptr := b.getValue(call.Args[0])
-		val := b.CreateLoad(ptr, "")
-		val.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
-		val.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
-		return val, true
-	case "StoreInt32", "StoreInt64", "StoreUint32", "StoreUint64", "StoreUintptr", "StorePointer":
-		ptr := b.getValue(call.Args[0])
-		val := b.getValue(call.Args[1])
-		store := b.CreateStore(val, ptr)
-		store.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
-		store.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
-		return store, true
-	default:
-		return llvm.Value{}, false
-	}
-}

compiler/calls.go

@@ -34,14 +34,12 @@ const (
 
 // createCall creates a new call to runtime.<fnName> with the given arguments.
 func (b *builder) createRuntimeCall(fnName string, args []llvm.Value, name string) llvm.Value {
-	fullName := "runtime." + fnName
-	fn := b.mod.NamedFunction(fullName)
-	if fn.IsNil() {
-		panic("trying to call non-existent function: " + fullName)
-	}
+	llvmFn := b.getFunctionRaw(b.getRuntimeFuncType(fnName), functionInfo{
+		linkName: "runtime." + fnName,
+	})
 	args = append(args, llvm.Undef(b.i8ptrType))            // unused context parameter
 	args = append(args, llvm.ConstPointerNull(b.i8ptrType)) // coroutine handle
-	return b.createCall(fn, args, name)
+	return b.createCall(llvmFn, args, name)
 }
 
 // createCall creates a call to the given function with the arguments possibly

compiler/channel.go

@@ -12,7 +12,7 @@ import (
 )
 
 func (b *builder) createMakeChan(expr *ssa.MakeChan) llvm.Value {
-	elementSize := b.targetData.TypeAllocSize(b.getLLVMType(expr.Type().Underlying().(*types.Chan).Elem()))
+	elementSize := b.targetData.TypeAllocSize(b.getLLVMType(expr.Type().(*types.Chan).Elem()))
 	elementSizeValue := llvm.ConstInt(b.uintptrType, elementSize, false)
 	bufSize := b.getValue(expr.Size)
 	b.createChanBoundsCheck(elementSize, bufSize, expr.Size.Type().Underlying().(*types.Basic), expr.Pos())
@@ -35,37 +35,27 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
 	b.CreateStore(chanValue, valueAlloca)
 
-	// Allocate blockedlist buffer.
-	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
-	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
-
 	// Do the send.
-	b.createRuntimeCall("chanSend", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")
+	b.createRuntimeCall("chanSend", []llvm.Value{ch, valueAllocaCast}, "")
 
-	// End the lifetime of the allocas.
+	// End the lifetime of the alloca.
 	// This also works around a bug in CoroSplit, at least in LLVM 8:
 	// https://bugs.llvm.org/show_bug.cgi?id=41742
-	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
 	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 }
 
 // createChanRecv emits a pseudo chan receive operation. It is lowered to the
 // actual channel receive operation during goroutine lowering.
 func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
-	valueType := b.getLLVMType(unop.X.Type().Underlying().(*types.Chan).Elem())
+	valueType := b.getLLVMType(unop.X.Type().(*types.Chan).Elem())
 	ch := b.getValue(unop.X)
 
 	// Allocate memory to receive into.
 	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
 
-	// Allocate blockedlist buffer.
-	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
-	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
-
 	// Do the receive.
-	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")
+	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast}, "")
 	received := b.CreateLoad(valueAlloca, "chan.received")
-	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
 	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 
 	if unop.CommaOk {
@@ -127,7 +117,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 		switch state.Dir {
 		case types.RecvOnly:
 			// Make sure the receive buffer is big enough and has the correct alignment.
-			llvmType := b.getLLVMType(state.Chan.Type().Underlying().(*types.Chan).Elem())
+			llvmType := b.getLLVMType(state.Chan.Type().(*types.Chan).Elem())
 			if size := b.targetData.TypeAllocSize(llvmType); size > recvbufSize {
 				recvbufSize = size
 			}

compiler/compiler.go

@@ -1,5 +1,7 @@
 package compiler
 
+//go:generate go run ./mkruntimetypes.go
+
 import (
 	"debug/dwarf"
 	"errors"
@@ -11,13 +13,13 @@ import (
 	"go/types"
 	"os"
 	"path/filepath"
+	"sort"
 	"strconv"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"github.com/tinygo-org/tinygo/goenv"
-	"github.com/tinygo-org/tinygo/ir"
 	"github.com/tinygo-org/tinygo/loader"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
@@ -49,18 +51,23 @@ type compilerContext struct {
 	targetData       llvm.TargetData
 	intType          llvm.Type
 	i8ptrType        llvm.Type // for convenience
+	runtimeTypes     map[string]types.Type
 	funcPtrAddrSpace int
 	uintptrType      llvm.Type
-	ir               *ir.Program
+	program          *ssa.Program
 	diagnostics      []error
 	astComments      map[string]*ast.CommentGroup
+	runtimePkg       *types.Package // package runtime
+	taskPkg          *types.Package // package internal/task
 }
 
 // builder contains all information relevant to build a single function.
 type builder struct {
 	*compilerContext
 	llvm.Builder
-	fn                *ir.Function
+	fn                *ssa.Function
+	llvmFn            llvm.Value
+	info              functionInfo
 	locals            map[ssa.Value]llvm.Value            // local variables
 	blockEntries      map[*ssa.BasicBlock]llvm.BasicBlock // a *ssa.BasicBlock may be split up
 	blockExits        map[*ssa.BasicBlock]llvm.BasicBlock // these are the exit blocks
@@ -71,9 +78,9 @@ type builder struct {
 	difunc            llvm.Metadata
 	dilocals          map[*types.Var]llvm.Metadata
 	allDeferFuncs     []interface{}
-	deferFuncs        map[*ir.Function]int
+	deferFuncs        map[*ssa.Function]int
 	deferInvokeFuncs  map[string]int
-	deferClosureFuncs map[*ir.Function]int
+	deferClosureFuncs map[*ssa.Function]int
 	selectRecvBuf     map[*ssa.Select]llvm.Value
 }
 
@@ -91,43 +98,20 @@ func NewTargetMachine(config *compileopts.Config) (llvm.TargetMachine, error) {
 		return llvm.TargetMachine{}, err
 	}
 	features := strings.Join(config.Features(), ",")
-
-	var codeModel llvm.CodeModel
-
-	switch config.CodeModel() {
-	case "default":
-		codeModel = llvm.CodeModelDefault
-	case "tiny":
-		codeModel = llvm.CodeModelTiny
-	case "small":
-		codeModel = llvm.CodeModelSmall
-	case "kernel":
-		codeModel = llvm.CodeModelKernel
-	case "medium":
-		codeModel = llvm.CodeModelMedium
-	case "large":
-		codeModel = llvm.CodeModelLarge
-	}
-
-	machine := target.CreateTargetMachine(config.Triple(), config.CPU(), features, llvm.CodeGenLevelDefault, llvm.RelocStatic, codeModel)
+	machine := target.CreateTargetMachine(config.Triple(), config.CPU(), features, llvm.CodeGenLevelDefault, llvm.RelocStatic, llvm.CodeModelDefault)
 	return machine, nil
 }
 
-// Compile the given package path or .go file path. Return an error when this
-// fails (in any stage). If successful it returns the LLVM module and a list of
-// extra C files to be compiled. If not, one or more errors will be returned.
-//
-// The fact that it returns a list of filenames to compile is a layering
-// violation. Eventually, this Compile function should only compile a single
-// package and not the whole program, and loading of the program (including CGo
-// processing) should be moved outside the compiler package.
-func Compile(pkgName string, machine llvm.TargetMachine, config *compileopts.Config) (mod llvm.Module, extrafiles []string, extraldflags []string, errors []error) {
+// newCompilerContext builds a new *compilerContext based on the provided
+// configuration, ready to compile Go SSA to LLVM IR.
+func newCompilerContext(pkgName string, machine llvm.TargetMachine, config *compileopts.Config) *compilerContext {
 	c := &compilerContext{
-		Config:     config,
-		difiles:    make(map[string]llvm.Metadata),
-		ditypes:    make(map[types.Type]llvm.Metadata),
-		machine:    machine,
-		targetData: machine.CreateTargetData(),
+		Config:       config,
+		difiles:      make(map[string]llvm.Metadata),
+		ditypes:      make(map[types.Type]llvm.Metadata),
+		machine:      machine,
+		targetData:   machine.CreateTargetData(),
+		runtimeTypes: make(map[string]types.Type),
 	}
 
 	c.ctx = llvm.NewContext()
@@ -155,26 +139,78 @@ func Compile(pkgName string, machine llvm.TargetMachine, config *compileopts.Con
 	c.funcPtrAddrSpace = dummyFunc.Type().PointerAddressSpace()
 	dummyFunc.EraseFromParentAsFunction()
 
+	return c
+}
+
+// Compile the given package path or .go file path. Return an error when this
+// fails (in any stage). If successful it returns the LLVM module and a list of
+// extra C files to be compiled. If not, one or more errors will be returned.
+//
+// The fact that it returns a list of filenames to compile is a layering
+// violation. Eventually, this Compile function should only compile a single
+// package and not the whole program, and loading of the program (including CGo
+// processing) should be moved outside the compiler package.
+func Compile(pkgName string, machine llvm.TargetMachine, config *compileopts.Config) (llvm.Module, []string, []error) {
+	c := newCompilerContext(pkgName, machine, config)
+
+	// Prefix the GOPATH with the system GOROOT, as GOROOT is already set to
+	// the TinyGo root.
+	overlayGopath := goenv.Get("GOPATH")
+	if overlayGopath == "" {
+		overlayGopath = goenv.Get("GOROOT")
+	} else {
+		overlayGopath = goenv.Get("GOROOT") + string(filepath.ListSeparator) + overlayGopath
+	}
+
 	wd, err := os.Getwd()
 	if err != nil {
-		return c.mod, nil, nil, []error{err}
-	}
-	goroot, err := loader.GetCachedGoroot(c.Config)
-	if err != nil {
-		return c.mod, nil, nil, []error{err}
+		return c.mod, nil, []error{err}
 	}
 	lprogram := &loader.Program{
 		Build: &build.Context{
 			GOARCH:      c.GOARCH(),
 			GOOS:        c.GOOS(),
-			GOROOT:      goroot,
+			GOROOT:      goenv.Get("GOROOT"),
 			GOPATH:      goenv.Get("GOPATH"),
 			CgoEnabled:  c.CgoEnabled(),
 			UseAllFiles: false,
 			Compiler:    "gc", // must be one of the recognized compilers
 			BuildTags:   c.BuildTags(),
 		},
-		Tests: c.TestConfig.CompileTestBinary,
+		OverlayBuild: &build.Context{
+			GOARCH:      c.GOARCH(),
+			GOOS:        c.GOOS(),
+			GOROOT:      goenv.Get("TINYGOROOT"),
+			GOPATH:      overlayGopath,
+			CgoEnabled:  c.CgoEnabled(),
+			UseAllFiles: false,
+			Compiler:    "gc", // must be one of the recognized compilers
+			BuildTags:   c.BuildTags(),
+		},
+		OverlayPath: func(path string) string {
+			// Return the (overlay) import path when it should be overlaid, and
+			// "" if it should not.
+			if strings.HasPrefix(path, tinygoPath+"/src/") {
+				// Avoid issues with packages that are imported twice, one from
+				// GOPATH and one from TINYGOPATH.
+				path = path[len(tinygoPath+"/src/"):]
+			}
+			switch path {
+			case "machine", "os", "reflect", "runtime", "runtime/interrupt", "runtime/volatile", "sync", "testing", "internal/reflectlite", "internal/task":
+				return path
+			default:
+				if strings.HasPrefix(path, "device/") || strings.HasPrefix(path, "examples/") {
+					return path
+				} else if path == "syscall" {
+					for _, tag := range c.BuildTags() {
+						if tag == "baremetal" || tag == "darwin" {
+							return path
+						}
+					}
+				}
+			}
+			return ""
+		},
 		TypeChecker: types.Config{
 			Sizes: &stdSizes{
 				IntSize:  int64(c.targetData.TypeAllocSize(c.intType)),
@@ -188,24 +224,37 @@ func Compile(pkgName string, machine llvm.TargetMachine, config *compileopts.Con
 		ClangHeaders: c.ClangHeaders,
 	}
 
-	err = lprogram.Load(pkgName)
-	if err != nil {
-		return c.mod, nil, nil, []error{err}
+	if strings.HasSuffix(pkgName, ".go") {
+		_, err = lprogram.ImportFile(pkgName)
+		if err != nil {
+			return c.mod, nil, []error{err}
+		}
+	} else {
+		_, err = lprogram.Import(pkgName, wd, token.Position{
+			Filename: "build command-line-arguments",
+		})
+		if err != nil {
+			return c.mod, nil, []error{err}
+		}
 	}
 
-	err = lprogram.Parse()
+	_, err = lprogram.Import("runtime", "", token.Position{
+		Filename: "build default import",
+	})
 	if err != nil {
-		return c.mod, nil, nil, []error{err}
+		return c.mod, nil, []error{err}
 	}
 
-	c.ir = ir.NewProgram(lprogram)
-
-	// Run a simple dead code elimination pass.
-	err = c.ir.SimpleDCE()
+	err = lprogram.Parse(c.TestConfig.CompileTestBinary)
 	if err != nil {
-		return c.mod, nil, nil, []error{err}
+		return c.mod, nil, []error{err}
 	}
 
+	c.program = lprogram.LoadSSA()
+	c.program.Build()
+	c.runtimePkg = c.program.ImportedPackage("runtime").Pkg
+	c.taskPkg = c.program.ImportedPackage("internal/task").Pkg
+
 	// Initialize debug information.
 	if c.Debug() {
 		c.cu = c.dibuilder.CreateCompileUnit(llvm.DICompileUnit{
@@ -219,64 +268,44 @@ func Compile(pkgName string, machine llvm.TargetMachine, config *compileopts.Con
 
 	c.loadASTComments(lprogram)
 
-	// Declare runtime types.
-	// TODO: lazily create runtime types in getLLVMRuntimeType when they are
-	// needed. Eventually this will be required anyway, when packages are
-	// compiled independently (and the runtime types are not available).
-	for _, member := range c.ir.Program.ImportedPackage("runtime").Members {
-		if member, ok := member.(*ssa.Type); ok {
-			if typ, ok := member.Type().(*types.Named); ok {
-				if _, ok := typ.Underlying().(*types.Struct); ok {
-					c.getLLVMType(typ)
+	// Predeclare the runtime.alloc function, which is used by the wordpack
+	// functionality.
+	c.getFunction(c.program.ImportedPackage("runtime").Members["alloc"].(*ssa.Function))
+
+	sortedPackages := sortPackages(c.program, pkgName)
+
+	// Find package initializers.
+	var initFuncs []llvm.Value
+	for _, pkg := range sortedPackages {
+		for _, member := range pkg.Members {
+			switch member := member.(type) {
+			case *ssa.Function:
+				if member.Synthetic == "package initializer" {
+					initFuncs = append(initFuncs, c.getFunction(member))
 				}
 			}
 		}
 	}
 
-	// Declare all functions.
-	for _, f := range c.ir.Functions {
-		c.createFunctionDeclaration(f)
-	}
-
 	// Add definitions to declarations.
-	var initFuncs []llvm.Value
 	irbuilder := c.ctx.NewBuilder()
 	defer irbuilder.Dispose()
-	for _, f := range c.ir.Functions {
-		if f.Synthetic == "package initializer" {
-			initFuncs = append(initFuncs, f.LLVMFn)
-		}
-		if f.CName() != "" {
-			continue
-		}
-		if f.Blocks == nil {
-			continue // external function
-		}
-
-		// Create the function definition.
-		b := builder{
-			compilerContext: c,
-			Builder:         irbuilder,
-			fn:              f,
-			locals:          make(map[ssa.Value]llvm.Value),
-			dilocals:        make(map[*types.Var]llvm.Metadata),
-			blockEntries:    make(map[*ssa.BasicBlock]llvm.BasicBlock),
-			blockExits:      make(map[*ssa.BasicBlock]llvm.BasicBlock),
-		}
-		b.createFunctionDefinition()
+	for _, pkg := range sortedPackages {
+		c.createPackage(pkg, irbuilder)
 	}
 
 	// After all packages are imported, add a synthetic initializer function
 	// that calls the initializer of each package.
-	initFn := c.ir.GetFunction(c.ir.Program.ImportedPackage("runtime").Members["initAll"].(*ssa.Function))
-	initFn.LLVMFn.SetLinkage(llvm.InternalLinkage)
-	initFn.LLVMFn.SetUnnamedAddr(true)
+	initFn := c.program.ImportedPackage("runtime").Members["initAll"].(*ssa.Function)
+	llvmInitFn := c.getFunction(initFn)
+	llvmInitFn.SetLinkage(llvm.InternalLinkage)
+	llvmInitFn.SetUnnamedAddr(true)
 	if c.Debug() {
 		difunc := c.attachDebugInfo(initFn)
-		pos := c.ir.Program.Fset.Position(initFn.Pos())
+		pos := c.program.Fset.Position(initFn.Pos())
 		irbuilder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 	}
-	block := c.ctx.AddBasicBlock(initFn.LLVMFn, "entry")
+	block := c.ctx.AddBasicBlock(llvmInitFn, "entry")
 	irbuilder.SetInsertPointAtEnd(block)
 	for _, fn := range initFuncs {
 		irbuilder.CreateCall(fn, []llvm.Value{llvm.Undef(c.i8ptrType), llvm.Undef(c.i8ptrType)}, "")
@@ -285,7 +314,7 @@ func Compile(pkgName string, machine llvm.TargetMachine, config *compileopts.Con
 
 	// Conserve for goroutine lowering. Without marking these as external, they
 	// would be optimized away.
-	realMain := c.mod.NamedFunction(c.ir.MainPkg().Pkg.Path() + ".main")
+	realMain := c.mod.NamedFunction(pkgName + ".main")
 	realMain.SetLinkage(llvm.ExternalLinkage) // keep alive until goroutine lowering
 
 	// Replace callMain placeholder with actual main function.
@@ -341,29 +370,91 @@ func Compile(pkgName string, machine llvm.TargetMachine, config *compileopts.Con
 
 	// Gather the list of (C) file paths that should be included in the build.
 	var extraFiles []string
-	for _, pkg := range c.ir.LoaderProgram.Sorted() {
-		for _, file := range pkg.OtherFiles {
-			switch strings.ToLower(filepath.Ext(file)) {
-			case ".c":
-				extraFiles = append(extraFiles, file)
-			}
+	for _, pkg := range lprogram.Sorted() {
+		for _, file := range pkg.CFiles {
+			extraFiles = append(extraFiles, filepath.Join(pkg.Package.Dir, file))
 		}
 	}
 
-	return c.mod, extraFiles, lprogram.LDFlags, c.diagnostics
+	return c.mod, extraFiles, c.diagnostics
+}
+
+// sortPackages returns a list of all packages, sorted by import order.
+func sortPackages(program *ssa.Program, mainPath string) []*ssa.Package {
+	// Find the main package, which is a bit difficult when running a .go file
+	// directly.
+	mainPkg := program.ImportedPackage(mainPath)
+	if mainPkg == nil {
+		for _, pkgInfo := range program.AllPackages() {
+			if pkgInfo.Pkg.Name() == "main" {
+				if mainPkg != nil {
+					panic("more than one main package found")
+				}
+				mainPkg = pkgInfo
+			}
+		}
+	}
+	if mainPkg == nil {
+		panic("could not find main package")
+	}
+
+	packageList := []*ssa.Package{}
+	packageSet := map[string]struct{}{}
+	worklist := []string{"runtime", mainPath}
+	for len(worklist) != 0 {
+		pkgPath := worklist[0]
+		var pkg *ssa.Package
+		if pkgPath == mainPath {
+			pkg = mainPkg // necessary for compiling individual .go files
+		} else {
+			pkg = program.ImportedPackage(pkgPath)
+		}
+		if pkg == nil {
+			// Non-SSA package (e.g. cgo).
+			packageSet[pkgPath] = struct{}{}
+			worklist = worklist[1:]
+			continue
+		}
+		if _, ok := packageSet[pkgPath]; ok {
+			// Package already in the final package list.
+			worklist = worklist[1:]
+			continue
+		}
+
+		unsatisfiedImports := make([]string, 0)
+		imports := pkg.Pkg.Imports()
+		for _, pkg := range imports {
+			if _, ok := packageSet[pkg.Path()]; ok {
+				continue
+			}
+			unsatisfiedImports = append(unsatisfiedImports, pkg.Path())
+		}
+		if len(unsatisfiedImports) == 0 {
+			// All dependencies of this package are satisfied, so add this
+			// package to the list.
+			packageList = append(packageList, pkg)
+			packageSet[pkgPath] = struct{}{}
+			worklist = worklist[1:]
+		} else {
+			// Prepend all dependencies to the worklist and reconsider this
+			// package (by not removing it from the worklist). At that point, it
+			// must be possible to add it to packageList.
+			worklist = append(unsatisfiedImports, worklist...)
+		}
+	}
+
+	return packageList
 }
 
 // getLLVMRuntimeType obtains a named type from the runtime package and returns
-// it as a LLVM type, creating it if necessary. It is a shorthand for
-// getLLVMType(getRuntimeType(name)).
+// it as a LLVM type, creating it if necessary.
 func (c *compilerContext) getLLVMRuntimeType(name string) llvm.Type {
 	fullName := "runtime." + name
-	typ := c.mod.GetTypeByName(fullName)
-	if typ.IsNil() {
-		println(c.mod.String())
-		panic("could not find runtime type: " + fullName)
+	llvmType := c.mod.GetTypeByName(fullName)
+	if llvmType.IsNil() {
+		llvmType = c.getLLVMType(c.getRuntimeType(name))
 	}
-	return typ
+	return llvmType
 }
 
 // getLLVMType creates and returns a LLVM type for a Go type. In the case of
@@ -423,6 +514,10 @@ func (c *compilerContext) getLLVMType(goType types.Type) llvm.Type {
 				llvmType = c.ctx.StructCreateNamed(llvmName)
 				underlying := c.getLLVMType(st)
 				llvmType.StructSetBody(underlying.StructElementTypes(), false)
+			} else if typ.String() == "internal/task.Task" && llvmType.StructElementTypesCount() == 0 {
+				// Note: this struct is an opaque struct. Give it a body.
+				underlying := c.getLLVMType(st)
+				llvmType.StructSetBody(underlying.StructElementTypes(), false)
 			}
 			return llvmType
 		}
@@ -443,6 +538,23 @@ func (c *compilerContext) getLLVMType(goType types.Type) llvm.Type {
 	case *types.Struct:
 		members := make([]llvm.Type, typ.NumFields())
 		for i := 0; i < typ.NumFields(); i++ {
+			if ptr, ok := typ.Field(i).Type().(*types.Pointer); ok {
+				if named, ok := ptr.Elem().(*types.Named); ok && named.String() == "internal/task.Task" {
+					// Special workaround for internal/task.Task. It is
+					// referenced from the runtime.channel type, which
+					// references runtime.channelBlockedList, which references
+					// internal/task.Task. To avoid having to define
+					// internal/task.Task as a compiler-internal type, make the
+					// type opaque.
+					ptrTo := c.mod.GetTypeByName(named.String())
+					if ptrTo.IsNil() {
+						ptrTo = c.ctx.StructCreateNamed(named.String())
+					}
+					members[i] = llvm.PointerType(ptrTo, 0)
+					continue
+				}
+			}
+
 			members[i] = c.getLLVMType(typ.Field(i).Type())
 		}
 		return c.ctx.StructType(members, false)
@@ -546,11 +658,11 @@ func (c *compilerContext) createDIType(typ types.Type) llvm.Metadata {
 			Encoding:   encoding,
 		})
 	case *types.Chan:
-		return c.getDIType(types.NewPointer(c.ir.Program.ImportedPackage("runtime").Members["channel"].(*ssa.Type).Type()))
+		return c.getDIType(types.NewPointer(c.getRuntimeType("channel")))
 	case *types.Interface:
-		return c.getDIType(c.ir.Program.ImportedPackage("runtime").Members["_interface"].(*ssa.Type).Type())
+		return c.getDIType(c.getRuntimeType("_interface"))
 	case *types.Map:
-		return c.getDIType(types.NewPointer(c.ir.Program.ImportedPackage("runtime").Members["hashmap"].(*ssa.Type).Type()))
+		return c.getDIType(types.NewPointer(c.getRuntimeType("hashmap")))
 	case *types.Named:
 		return c.dibuilder.CreateTypedef(llvm.DITypedef{
 			Type: c.getDIType(typ.Underlying()),
@@ -658,7 +770,7 @@ func (b *builder) getLocalVariable(variable *types.Var) llvm.Metadata {
 		return dilocal
 	}
 
-	pos := b.ir.Program.Fset.Position(variable.Pos())
+	pos := b.program.Fset.Position(variable.Pos())
 
 	// Check whether this is a function parameter.
 	for i, param := range b.fn.Params {
@@ -689,95 +801,17 @@ func (b *builder) getLocalVariable(variable *types.Var) llvm.Metadata {
 	return dilocal
 }
 
-// createFunctionDeclaration creates a LLVM function declaration without body.
-// It can later be filled with frame.createFunctionDefinition().
-func (c *compilerContext) createFunctionDeclaration(f *ir.Function) {
-	var retType llvm.Type
-	if f.Signature.Results() == nil {
-		retType = c.ctx.VoidType()
-	} else if f.Signature.Results().Len() == 1 {
-		retType = c.getLLVMType(f.Signature.Results().At(0).Type())
-	} else {
-		results := make([]llvm.Type, 0, f.Signature.Results().Len())
-		for i := 0; i < f.Signature.Results().Len(); i++ {
-			results = append(results, c.getLLVMType(f.Signature.Results().At(i).Type()))
-		}
-		retType = c.ctx.StructType(results, false)
-	}
-
-	var paramInfos []paramInfo
-	for _, param := range f.Params {
-		paramType := c.getLLVMType(param.Type())
-		paramFragmentInfos := expandFormalParamType(paramType, param.Name(), param.Type())
-		paramInfos = append(paramInfos, paramFragmentInfos...)
-	}
-
-	// Add an extra parameter as the function context. This context is used in
-	// closures and bound methods, but should be optimized away when not used.
-	if !f.IsExported() {
-		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "context", flags: 0})
-		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "parentHandle", flags: 0})
-	}
-
-	var paramTypes []llvm.Type
-	for _, info := range paramInfos {
-		paramTypes = append(paramTypes, info.llvmType)
-	}
-
-	fnType := llvm.FunctionType(retType, paramTypes, false)
-
-	name := f.LinkName()
-	f.LLVMFn = c.mod.NamedFunction(name)
-	if f.LLVMFn.IsNil() {
-		f.LLVMFn = llvm.AddFunction(c.mod, name, fnType)
-	}
-
-	dereferenceableOrNullKind := llvm.AttributeKindID("dereferenceable_or_null")
-	for i, info := range paramInfos {
-		if info.flags&paramIsDeferenceableOrNull == 0 {
-			continue
-		}
-		if info.llvmType.TypeKind() == llvm.PointerTypeKind {
-			el := info.llvmType.ElementType()
-			size := c.targetData.TypeAllocSize(el)
-			if size == 0 {
-				// dereferenceable_or_null(0) appears to be illegal in LLVM.
-				continue
-			}
-			dereferenceableOrNull := c.ctx.CreateEnumAttribute(dereferenceableOrNullKind, size)
-			f.LLVMFn.AddAttributeAtIndex(i+1, dereferenceableOrNull)
-		}
-	}
-
-	// External/exported functions may not retain pointer values.
-	// https://golang.org/cmd/cgo/#hdr-Passing_pointers
-	if f.IsExported() {
-		// Set the wasm-import-module attribute if the function's module is set.
-		if f.Module() != "" {
-			wasmImportModuleAttr := c.ctx.CreateStringAttribute("wasm-import-module", f.Module())
-			f.LLVMFn.AddFunctionAttr(wasmImportModuleAttr)
-		}
-		nocaptureKind := llvm.AttributeKindID("nocapture")
-		nocapture := c.ctx.CreateEnumAttribute(nocaptureKind, 0)
-		for i, typ := range paramTypes {
-			if typ.TypeKind() == llvm.PointerTypeKind {
-				f.LLVMFn.AddAttributeAtIndex(i+1, nocapture)
-			}
-		}
-	}
-}
-
 // attachDebugInfo adds debug info to a function declaration. It returns the
 // DISubprogram metadata node.
-func (c *compilerContext) attachDebugInfo(f *ir.Function) llvm.Metadata {
-	pos := c.ir.Program.Fset.Position(f.Syntax().Pos())
-	return c.attachDebugInfoRaw(f, f.LLVMFn, "", pos.Filename, pos.Line)
+func (c *compilerContext) attachDebugInfo(f *ssa.Function) llvm.Metadata {
+	pos := c.program.Fset.Position(f.Syntax().Pos())
+	return c.attachDebugInfoRaw(f, c.getFunction(f), "", pos.Filename, pos.Line)
 }
 
 // attachDebugInfo adds debug info to a function declaration. It returns the
 // DISubprogram metadata node. This method allows some more control over how
 // debug info is added to the function.
-func (c *compilerContext) attachDebugInfoRaw(f *ir.Function, llvmFn llvm.Value, suffix, filename string, line int) llvm.Metadata {
+func (c *compilerContext) attachDebugInfoRaw(f *ssa.Function, llvmFn llvm.Value, suffix, filename string, line int) llvm.Metadata {
 	// Debug info for this function.
 	diparams := make([]llvm.Metadata, 0, len(f.Params))
 	for _, param := range f.Params {
@@ -790,7 +824,7 @@ func (c *compilerContext) attachDebugInfoRaw(f *ir.Function, llvmFn llvm.Value,
 	})
 	difunc := c.dibuilder.CreateFunction(c.getDIFile(filename), llvm.DIFunction{
 		Name:         f.RelString(nil) + suffix,
-		LinkageName:  f.LinkName() + suffix,
+		LinkageName:  c.getFunctionInfo(f).linkName + suffix,
 		File:         c.getDIFile(filename),
 		Line:         line,
 		Type:         diFuncType,
@@ -818,37 +852,99 @@ func (c *compilerContext) getDIFile(filename string) llvm.Metadata {
 	return c.difiles[filename]
 }
 
-// createFunctionDefinition builds the LLVM IR implementation for this function.
-// The function must be declared but not yet defined, otherwise this function
-// will create a diagnostic.
-func (b *builder) createFunctionDefinition() {
-	if b.DumpSSA() {
-		fmt.Printf("\nfunc %s:\n", b.fn.Function)
+func (c *compilerContext) createPackage(pkg *ssa.Package, irbuilder llvm.Builder) {
+	memberNames := make([]string, 0)
+	for name := range pkg.Members {
+		memberNames = append(memberNames, name)
 	}
-	if !b.fn.LLVMFn.IsDeclaration() {
+	sort.Strings(memberNames)
+
+	for _, name := range memberNames {
+		switch member := pkg.Members[name].(type) {
+		case *ssa.Function:
+			llvmFn := c.getFunction(member)
+			if member.Blocks == nil {
+				continue // external function
+			}
+			c.createFunction(irbuilder, member, llvmFn)
+		case *ssa.Type:
+			if types.IsInterface(member.Type()) {
+				// Interfaces don't have concrete methods.
+				continue
+			}
+
+			// Named type. We should make sure all methods are created.
+			// This includes both functions with pointer receivers and those
+			// without.
+			methods := getAllMethods(pkg.Prog, member.Type())
+			methods = append(methods, getAllMethods(pkg.Prog, types.NewPointer(member.Type()))...)
+			for _, method := range methods {
+				// Parse this method.
+				fn := pkg.Prog.MethodValue(method)
+				if fn.Blocks == nil {
+					continue // external function
+				}
+				if member.Type().String() != member.String() {
+					// This is a member on a type alias. Do not build such a
+					// function.
+					continue
+				}
+				c.createFunction(irbuilder, fn, c.getFunction(fn))
+			}
+		case *ssa.Global:
+			// Make sure the global is present and has an initializer.
+			c.getGlobal(member)
+		case *ssa.NamedConst:
+			// TODO: create DWARF entries for these.
+		default:
+			panic("unknown member type: " + member.String())
+		}
+	}
+}
+
+// createFunction builds the LLVM IR implementation for this function. The
+// function must not yet be defined, otherwise this function will create a
+// diagnostic.
+func (c *compilerContext) createFunction(irbuilder llvm.Builder, fn *ssa.Function, llvmFn llvm.Value) {
+	b := builder{
+		compilerContext: c,
+		Builder:         irbuilder,
+		fn:              fn,
+		llvmFn:          llvmFn,
+		info:            c.getFunctionInfo(fn),
+		locals:          make(map[ssa.Value]llvm.Value),
+		dilocals:        make(map[*types.Var]llvm.Metadata),
+		blockEntries:    make(map[*ssa.BasicBlock]llvm.BasicBlock),
+		blockExits:      make(map[*ssa.BasicBlock]llvm.BasicBlock),
+	}
+
+	if b.DumpSSA() {
+		fmt.Printf("\nfunc %s:\n", b.fn)
+	}
+	if !b.llvmFn.IsDeclaration() {
 		errValue := b.fn.Name() + " redeclared in this program"
-		fnPos := getPosition(b.fn.LLVMFn)
+		fnPos := getPosition(b.llvmFn)
 		if fnPos.IsValid() {
 			errValue += "\n\tprevious declaration at " + fnPos.String()
 		}
 		b.addError(b.fn.Pos(), errValue)
 		return
 	}
-	if !b.fn.IsExported() {
-		b.fn.LLVMFn.SetLinkage(llvm.InternalLinkage)
-		b.fn.LLVMFn.SetUnnamedAddr(true)
+	if !b.info.exported {
+		b.llvmFn.SetLinkage(llvm.InternalLinkage)
+		b.llvmFn.SetUnnamedAddr(true)
 	}
 
 	// Some functions have a pragma controlling the inlining level.
-	switch b.fn.Inline() {
-	case ir.InlineHint:
+	switch b.info.inline {
+	case inlineHint:
 		// Add LLVM inline hint to functions with //go:inline pragma.
 		inline := b.ctx.CreateEnumAttribute(llvm.AttributeKindID("inlinehint"), 0)
-		b.fn.LLVMFn.AddFunctionAttr(inline)
-	case ir.InlineNone:
+		b.llvmFn.AddFunctionAttr(inline)
+	case inlineNone:
 		// Add LLVM attribute to always avoid inlining this function.
 		noinline := b.ctx.CreateEnumAttribute(llvm.AttributeKindID("noinline"), 0)
-		b.fn.LLVMFn.AddFunctionAttr(noinline)
+		b.llvmFn.AddFunctionAttr(noinline)
 	}
 
 	// Add debug info, if needed.
@@ -857,18 +953,18 @@ func (b *builder) createFunctionDefinition() {
 			// Package initializers have no debug info. Create some fake debug
 			// info to at least have *something*.
 			filename := b.fn.Package().Pkg.Path() + "/<init>"
-			b.difunc = b.attachDebugInfoRaw(b.fn, b.fn.LLVMFn, "", filename, 0)
+			b.difunc = b.attachDebugInfoRaw(b.fn, b.llvmFn, "", filename, 0)
 		} else if b.fn.Syntax() != nil {
 			// Create debug info file if needed.
 			b.difunc = b.attachDebugInfo(b.fn)
 		}
-		pos := b.ir.Program.Fset.Position(b.fn.Pos())
+		pos := b.program.Fset.Position(b.fn.Pos())
 		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
 	}
 
 	// Pre-create all basic blocks in the function.
 	for _, block := range b.fn.DomPreorder() {
-		llvmBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, block.Comment)
+		llvmBlock := b.ctx.AddBasicBlock(b.llvmFn, block.Comment)
 		b.blockEntries[block] = llvmBlock
 		b.blockExits[block] = llvmBlock
 	}
@@ -881,7 +977,7 @@ func (b *builder) createFunctionDefinition() {
 		llvmType := b.getLLVMType(param.Type())
 		fields := make([]llvm.Value, 0, 1)
 		for _, info := range expandFormalParamType(llvmType, param.Name(), param.Type()) {
-			param := b.fn.LLVMFn.Param(llvmParamIndex)
+			param := b.llvmFn.Param(llvmParamIndex)
 			param.SetName(info.name)
 			fields = append(fields, param)
 			llvmParamIndex++
@@ -912,8 +1008,8 @@ func (b *builder) createFunctionDefinition() {
 	// Load free variables from the context. This is a closure (or bound
 	// method).
 	var context llvm.Value
-	if !b.fn.IsExported() {
-		parentHandle := b.fn.LLVMFn.LastParam()
+	if !b.info.exported {
+		parentHandle := b.llvmFn.LastParam()
 		parentHandle.SetName("parentHandle")
 		context = llvm.PrevParam(parentHandle)
 		context.SetName("context")
@@ -964,7 +1060,7 @@ func (b *builder) createFunctionDefinition() {
 					continue
 				}
 				dbgVar := b.getLocalVariable(variable)
-				pos := b.ir.Program.Fset.Position(instr.Pos())
+				pos := b.program.Fset.Position(instr.Pos())
 				b.dibuilder.InsertValueAtEnd(b.getValue(instr.X), dbgVar, b.dibuilder.CreateExpression(nil), llvm.DebugLoc{
 					Line:  uint(pos.Line),
 					Col:   uint(pos.Column),
@@ -1007,13 +1103,18 @@ func (b *builder) createFunctionDefinition() {
 			b.trackValue(phi.llvm)
 		}
 	}
+
+	// Compile all anonymous functions part of this function.
+	for _, fn := range b.fn.AnonFuncs {
+		b.createFunction(b.Builder, fn, b.getFunction(fn))
+	}
 }
 
 // createInstruction builds the LLVM IR equivalent instructions for the
 // particular Go SSA instruction.
 func (b *builder) createInstruction(instr ssa.Instruction) {
 	if b.Debug() {
-		pos := b.ir.Program.Fset.Position(instr.Pos())
+		pos := b.program.Fset.Position(instr.Pos())
 		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
 	}
 
@@ -1049,7 +1150,7 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 		if callee := instr.Call.StaticCallee(); callee != nil {
 			// Static callee is known. This makes it easier to start a new
 			// goroutine.
-			calleeFn := b.ir.GetFunction(callee)
+			calleeFn := b.getFunction(callee)
 			var context llvm.Value
 			switch value := instr.Call.Value.(type) {
 			case *ssa.Function:
@@ -1064,14 +1165,14 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 				panic("StaticCallee returned an unexpected value")
 			}
 			params = append(params, context) // context parameter
-			b.createGoInstruction(calleeFn.LLVMFn, params, "", callee.Pos())
+			b.createGoInstruction(calleeFn, params, "", callee.Pos())
 		} else if !instr.Call.IsInvoke() {
 			// This is a function pointer.
 			// At the moment, two extra params are passed to the newly started
 			// goroutine:
 			//   * The function context, for closures.
 			//   * The function pointer (for tasks).
-			funcPtr, context := b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
+			funcPtr, context := b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().(*types.Signature))
 			params = append(params, context) // context parameter
 			switch b.Scheduler() {
 			case "none", "coroutines":
@@ -1112,7 +1213,7 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 			b.CreateRet(b.getValue(instr.Results[0]))
 		} else {
 			// Multiple return values. Put them all in a struct.
-			retVal := llvm.ConstNull(b.fn.LLVMFn.Type().ElementType().ReturnType())
+			retVal := llvm.ConstNull(b.llvmFn.Type().ElementType().ReturnType())
 			for i, result := range instr.Results {
 				val := b.getValue(result)
 				retVal = b.CreateInsertValue(retVal, val, i, "")
@@ -1168,7 +1269,9 @@ func (b *builder) createBuiltin(args []ssa.Value, callName string, pos token.Pos
 		var llvmCap llvm.Value
 		switch args[0].Type().(type) {
 		case *types.Chan:
-			llvmCap = b.createRuntimeCall("chanCap", []llvm.Value{value}, "cap")
+			// Channel. Buffered channels haven't been implemented yet so always
+			// return 0.
+			llvmCap = llvm.ConstInt(b.intType, 0, false)
 		case *types.Slice:
 			llvmCap = b.CreateExtractValue(value, 2, "cap")
 		default:
@@ -1224,7 +1327,9 @@ func (b *builder) createBuiltin(args []ssa.Value, callName string, pos token.Pos
 			// string or slice
 			llvmLen = b.CreateExtractValue(value, 1, "len")
 		case *types.Chan:
-			llvmLen = b.createRuntimeCall("chanLen", []llvm.Value{value}, "len")
+			// Channel. Buffered channels haven't been implemented yet so always
+			// return 0.
+			llvmLen = llvm.ConstInt(b.intType, 0, false)
 		case *types.Map:
 			llvmLen = b.createRuntimeCall("hashmapLen", []llvm.Value{value}, "len")
 		default:
@@ -1327,35 +1432,36 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.createMemoryCopyCall(fn, instr.Args)
 		case name == "runtime.memzero":
 			return b.createMemoryZeroCall(instr.Args)
-		case name == "device.Asm" || name == "device/arm.Asm" || name == "device/avr.Asm" || name == "device/riscv.Asm":
+		case name == "device/arm.Asm" || name == "device/avr.Asm" || name == "device/riscv.Asm":
 			return b.createInlineAsm(instr.Args)
-		case name == "device.AsmFull" || name == "device/arm.AsmFull" || name == "device/avr.AsmFull" || name == "device/riscv.AsmFull":
+		case name == "device/arm.AsmFull" || name == "device/avr.AsmFull" || name == "device/riscv.AsmFull":
 			return b.createInlineAsmFull(instr)
 		case strings.HasPrefix(name, "device/arm.SVCall"):
 			return b.emitSVCall(instr.Args)
 		case strings.HasPrefix(name, "(device/riscv.CSR)."):
-			return b.emitCSROperation(instr)
+			// The device/riscv.CSR operations must happen on constants.
+			// However, the compiler also creates pointer receivers for this
+			// operation which do not provide constant parameters. Therefore, do
+			// not create the regular inline asm for such functions but leave
+			// the call to an undefined function instead.
+			recv := b.fn.Signature.Recv()
+			if recv == nil || recv.Type().String() != "*device/riscv.CSR" {
+				return b.emitCSROperation(instr)
+			}
 		case strings.HasPrefix(name, "syscall.Syscall"):
 			return b.createSyscall(instr)
 		case strings.HasPrefix(name, "runtime/volatile.Load"):
 			return b.createVolatileLoad(instr)
 		case strings.HasPrefix(name, "runtime/volatile.Store"):
 			return b.createVolatileStore(instr)
-		case strings.HasPrefix(name, "sync/atomic."):
-			val, ok := b.createAtomicOp(instr)
-			if ok {
-				// This call could be lowered as an atomic operation.
-				return val, nil
-			}
-			// This call couldn't be lowered as an atomic operation, it's
-			// probably something else. Continue as usual.
 		case name == "runtime/interrupt.New":
 			return b.createInterruptGlobal(instr)
 		}
 
-		targetFunc := b.ir.GetFunction(fn)
-		if targetFunc.LLVMFn.IsNil() {
-			return llvm.Value{}, b.makeError(instr.Pos(), "undefined function: "+targetFunc.LinkName())
+		callee = b.getFunction(fn)
+		info := b.getFunctionInfo(fn)
+		if callee.IsNil() {
+			return llvm.Value{}, b.makeError(instr.Pos(), "undefined function: "+info.linkName)
 		}
 		switch value := instr.Value.(type) {
 		case *ssa.Function:
@@ -1369,8 +1475,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		default:
 			panic("StaticCallee returned an unexpected value")
 		}
-		callee = targetFunc.LLVMFn
-		exported = targetFunc.IsExported()
+		exported = info.exported
 	} else if call, ok := instr.Value.(*ssa.Builtin); ok {
 		// Builtin function (append, close, delete, etc.).)
 		return b.createBuiltin(instr.Args, call.Name(), instr.Pos())
@@ -1405,14 +1510,15 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 func (b *builder) getValue(expr ssa.Value) llvm.Value {
 	switch expr := expr.(type) {
 	case *ssa.Const:
-		return b.createConst(b.fn.LinkName(), expr)
+		return b.createConst(b.info.linkName, expr)
 	case *ssa.Function:
-		fn := b.ir.GetFunction(expr)
-		if fn.IsExported() {
+		info := b.getFunctionInfo(expr)
+		if info.exported {
 			b.addError(expr.Pos(), "cannot use an exported function as value: "+expr.String())
 			return llvm.Undef(b.getLLVMType(expr.Type()))
 		}
-		return b.createFuncValue(fn.LLVMFn, llvm.Undef(b.i8ptrType), fn.Signature)
+		llvmFn := b.getFunction(expr)
+		return b.createFuncValue(llvmFn, llvm.Undef(b.i8ptrType), expr.Signature)
 	case *ssa.Global:
 		value := b.getGlobal(expr)
 		if value.IsNil() {
@@ -1542,7 +1648,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		index := b.getValue(expr.Index)
 
 		// Check bounds.
-		arrayLen := expr.X.Type().Underlying().(*types.Array).Len()
+		arrayLen := expr.X.Type().(*types.Array).Len()
 		arrayLenLLVM := llvm.ConstInt(b.uintptrType, uint64(arrayLen), false)
 		b.createLookupBoundsCheck(arrayLenLLVM, index, expr.Index.Type())
 
@@ -1654,8 +1760,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		}
 
 		// Bounds checking.
-		lenType := expr.Len.Type().Underlying().(*types.Basic)
-		capType := expr.Cap.Type().Underlying().(*types.Basic)
+		lenType := expr.Len.Type().(*types.Basic)
+		capType := expr.Cap.Type().(*types.Basic)
 		b.createSliceBoundsCheck(maxSize, sliceLen, sliceCap, sliceCap, lenType, capType, capType)
 
 		// Allocate the backing array.

compiler/compiler_test.go

@@ -0,0 +1,138 @@
+package compiler
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+	"github.com/tinygo-org/tinygo/compiler/ircheck"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+	"tinygo.org/x/go-llvm"
+)
+
+var flagUpdate = flag.Bool("update", false, "update all tests")
+
+func TestCompiler(t *testing.T) {
+	t.Parallel()
+	for _, name := range []string{"basic"} {
+		t.Run(name, func(t *testing.T) {
+			runCompilerTest(t, name)
+		})
+	}
+}
+
+func runCompilerTest(t *testing.T, name string) {
+	// Read the AST in memory.
+	path := filepath.Join("testdata", name+".go")
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, path, nil, parser.ParseComments)
+	if err != nil {
+		t.Fatal("could not parse Go source file:", err)
+	}
+	files := []*ast.File{f}
+
+	// Create Go SSA from the AST.
+	var typecheckErrors []error
+	var typecheckErrorsLock sync.Mutex
+	typesConfig := types.Config{
+		Error: func(err error) {
+			typecheckErrorsLock.Lock()
+			defer typecheckErrorsLock.Unlock()
+			typecheckErrors = append(typecheckErrors, err)
+		},
+		Importer: simpleImporter{},
+		Sizes:    types.SizesFor("gccgo", "arm"),
+	}
+	pkg, _, err := ssautil.BuildPackage(&typesConfig, fset, types.NewPackage("main", ""), files, ssa.SanityCheckFunctions|ssa.BareInits|ssa.GlobalDebug)
+	for _, err := range typecheckErrors {
+		t.Error(err)
+	}
+	if err != nil && len(typecheckErrors) == 0 {
+		// Only report errors when no type errors are found (an
+		// unexpected condition).
+		t.Error(err)
+	}
+	if t.Failed() {
+		return
+	}
+
+	// Configure the compiler.
+	config := compileopts.Config{
+		Options: &compileopts.Options{},
+		Target: &compileopts.TargetSpec{
+			Triple:    "armv7m-none-eabi",
+			BuildTags: []string{"cortexm", "baremetal", "linux", "arm"},
+			Scheduler: "tasks",
+		},
+	}
+	machine, err := NewTargetMachine(&config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	c := newCompilerContext("main", machine, &config)
+	c.runtimePkg = types.NewPackage("runtime", "runtime")
+	c.taskPkg = types.NewPackage("internal/task", "task")
+	irbuilder := c.ctx.NewBuilder()
+	defer irbuilder.Dispose()
+
+	// Create LLVM IR from the Go SSA.
+	c.createPackage(pkg, irbuilder)
+
+	// Check the IR with the LLVM verifier.
+	if err := llvm.VerifyModule(c.mod, llvm.PrintMessageAction); err != nil {
+		t.Error("verification error after IR construction")
+	}
+
+	// Check the IR with our own verifier (which checks for different things).
+	errs := ircheck.Module(c.mod)
+	for _, err := range errs {
+		t.Error(err)
+	}
+
+	// Check whether the IR matches the expected IR.
+	ir := c.mod.String()
+	ir = ir[strings.Index(ir, "\ntarget datalayout = ")+1:]
+	outfile := filepath.Join("testdata", name+".ll")
+	if *flagUpdate {
+		err := ioutil.WriteFile(outfile, []byte(ir), 0666)
+		if err != nil {
+			t.Error("could not read output file:", err)
+		}
+	} else {
+		ir2, err := ioutil.ReadFile(outfile)
+		if err != nil {
+			t.Fatal("could not read input file:", err)
+		}
+		ir2 = bytes.Replace(ir2, []byte("\r\n"), []byte("\n"), -1)
+		if ir != string(ir2) {
+			t.Error("output did not match")
+		}
+	}
+}
+
+// simpleImporter implements the types.Importer interface, but only allows
+// importing the unsafe package.
+type simpleImporter struct {
+}
+
+// Import implements the Importer interface. For testing usage only: it only
+// supports importing the unsafe package.
+func (i simpleImporter) Import(path string) (*types.Package, error) {
+	switch path {
+	case "unsafe":
+		return types.Unsafe, nil
+	default:
+		return nil, fmt.Errorf("importer not implemented for package %s", path)
+	}
+}

compiler/defer.go

@@ -15,7 +15,6 @@ package compiler
 
 import (
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
-	"github.com/tinygo-org/tinygo/ir"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -25,9 +24,9 @@ import (
 // calls.
 func (b *builder) deferInitFunc() {
 	// Some setup.
-	b.deferFuncs = make(map[*ir.Function]int)
+	b.deferFuncs = make(map[*ssa.Function]int)
 	b.deferInvokeFuncs = make(map[string]int)
-	b.deferClosureFuncs = make(map[*ir.Function]int)
+	b.deferClosureFuncs = make(map[*ssa.Function]int)
 
 	// Create defer list pointer.
 	deferType := llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)
@@ -104,13 +103,12 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 
 	} else if callee, ok := instr.Call.Value.(*ssa.Function); ok {
 		// Regular function call.
-		fn := b.ir.GetFunction(callee)
 
-		if _, ok := b.deferFuncs[fn]; !ok {
-			b.deferFuncs[fn] = len(b.allDeferFuncs)
-			b.allDeferFuncs = append(b.allDeferFuncs, fn)
+		if _, ok := b.deferFuncs[callee]; !ok {
+			b.deferFuncs[callee] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, callee)
 		}
-		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[fn]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[callee]), false)
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields).
@@ -132,7 +130,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		context := b.CreateExtractValue(closure, 0, "")
 
 		// Get the callback number.
-		fn := b.ir.GetFunction(makeClosure.Fn.(*ssa.Function))
+		fn := makeClosure.Fn.(*ssa.Function)
 		if _, ok := b.deferClosureFuncs[fn]; !ok {
 			b.deferClosureFuncs[fn] = len(b.allDeferFuncs)
 			b.allDeferFuncs = append(b.allDeferFuncs, makeClosure)
@@ -203,10 +201,10 @@ func (b *builder) createRunDefers() {
 	//     }
 
 	// Create loop.
-	loophead := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.loophead")
-	loop := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.loop")
-	unreachable := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.default")
-	end := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.end")
+	loophead := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.loophead")
+	loop := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.loop")
+	unreachable := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.default")
+	end := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.end")
 	b.CreateBr(loophead)
 
 	// Create loop head:
@@ -238,7 +236,7 @@ func (b *builder) createRunDefers() {
 		// Create switch case, for example:
 		//     case 0:
 		//         // run first deferred call
-		block := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.callback")
+		block := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.callback")
 		sw.AddCase(llvm.ConstInt(b.uintptrType, uint64(i), false), block)
 		b.SetInsertPointAtEnd(block)
 		switch callback := callback.(type) {
@@ -279,7 +277,7 @@ func (b *builder) createRunDefers() {
 			fnPtr := b.getInvokePtr(callback, typecode)
 			b.createCall(fnPtr, forwardParams, "")
 
-		case *ir.Function:
+		case *ssa.Function:
 			// Direct call.
 
 			// Get the real defer struct type and cast to it.
@@ -301,7 +299,7 @@ func (b *builder) createRunDefers() {
 
 			// Plain TinyGo functions add some extra parameters to implement async functionality and function recievers.
 			// These parameters should not be supplied when calling into an external C/ASM function.
-			if !callback.IsExported() {
+			if !b.getFunctionInfo(callback).exported {
 				// Add the context parameter. We know it is ignored by the receiving
 				// function, but we have to pass one anyway.
 				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
@@ -311,11 +309,11 @@ func (b *builder) createRunDefers() {
 			}
 
 			// Call real function.
-			b.createCall(callback.LLVMFn, forwardParams, "")
+			b.createCall(b.getFunction(callback), forwardParams, "")
 
 		case *ssa.MakeClosure:
 			// Get the real defer struct type and cast to it.
-			fn := b.ir.GetFunction(callback.Fn.(*ssa.Function))
+			fn := callback.Fn.(*ssa.Function)
 			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
 			params := fn.Signature.Params()
 			for i := 0; i < params.Len(); i++ {
@@ -338,7 +336,7 @@ func (b *builder) createRunDefers() {
 			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 
 			// Call deferred function.
-			b.createCall(fn.LLVMFn, forwardParams, "")
+			b.createCall(b.getFunction(fn), forwardParams, "")
 
 		default:
 			panic("unknown deferred function type")

compiler/errors.go

@@ -14,7 +14,7 @@ import (
 // makeError makes it easy to create an error from a token.Pos with a message.
 func (c *compilerContext) makeError(pos token.Pos, msg string) types.Error {
 	return types.Error{
-		Fset: c.ir.Program.Fset,
+		Fset: c.program.Fset,
 		Pos:  pos,
 		Msg:  msg,
 	}

compiler/func.go

@@ -5,6 +5,7 @@ package compiler
 
 import (
 	"go/types"
+	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
 	"golang.org/x/tools/go/ssa"
@@ -149,7 +150,16 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	if len(expr.Bindings) == 0 {
 		panic("unexpected: MakeClosure without bound variables")
 	}
-	f := b.ir.GetFunction(expr.Fn.(*ssa.Function))
+	f := expr.Fn.(*ssa.Function)
+	llvmFn := b.getFunction(f)
+
+	if strings.HasSuffix(f.Name(), "$bound") && llvmFn.IsDeclaration() {
+		// Hack: the ssa package does not expose bound methods so make sure
+		// they're built here when necessary.
+		irbuilder := b.ctx.NewBuilder()
+		defer irbuilder.Dispose()
+		b.createFunction(irbuilder, f, llvmFn)
+	}
 
 	// Collect all bound variables.
 	boundVars := make([]llvm.Value, len(expr.Bindings))
@@ -164,5 +174,5 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	context := b.emitPointerPack(boundVars)
 
 	// Create the closure.
-	return b.createFuncValue(f.LLVMFn, context, f.Signature), nil
+	return b.createFuncValue(llvmFn, context, f.Signature), nil
 }

compiler/goroutine.go

@@ -7,6 +7,7 @@ import (
 	"go/token"
 
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
+	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -28,7 +29,8 @@ func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, p
 	default:
 		panic("unreachable")
 	}
-	b.createCall(b.mod.NamedFunction("internal/task.start"), []llvm.Value{callee, paramBundle, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
+	start := b.getFunction(b.program.ImportedPackage("internal/task").Members["start"].(*ssa.Function))
+	b.createCall(start, []llvm.Value{callee, paramBundle, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
 	return llvm.Undef(funcPtr.Type().ElementType().ReturnType())
 }
 
@@ -73,7 +75,7 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		builder.SetInsertPointAtEnd(entry)
 
 		if c.Debug() {
-			pos := c.ir.Program.Fset.Position(pos)
+			pos := c.program.Fset.Position(pos)
 			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
 				File:       c.getDIFile(pos.Filename),
 				Parameters: nil, // do not show parameters in debugger
@@ -129,7 +131,7 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		builder.SetInsertPointAtEnd(entry)
 
 		if c.Debug() {
-			pos := c.ir.Program.Fset.Position(pos)
+			pos := c.program.Fset.Position(pos)
 			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
 				File:       c.getDIFile(pos.Filename),
 				Parameters: nil, // do not show parameters in debugger

compiler/interface.go

@@ -11,7 +11,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/tinygo-org/tinygo/ir"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -236,7 +235,7 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 		return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 	}
 
-	ms := c.ir.Program.MethodSets.MethodSet(typ)
+	ms := c.program.MethodSets.MethodSet(typ)
 	if ms.Len() == 0 {
 		// no methods, so can leave that one out
 		return llvm.ConstPointerNull(llvm.PointerType(c.getLLVMRuntimeType("interfaceMethodInfo"), 0))
@@ -247,15 +246,23 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 	for i := 0; i < ms.Len(); i++ {
 		method := ms.At(i)
 		signatureGlobal := c.getMethodSignature(method.Obj().(*types.Func))
-		f := c.ir.GetFunction(c.ir.Program.MethodValue(method))
-		if f.LLVMFn.IsNil() {
+		fn := c.program.MethodValue(method)
+		llvmFn := c.getFunction(fn)
+		if llvmFn.IsNil() {
 			// compiler error, so panic
-			panic("cannot find function: " + f.LinkName())
+			panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
 		}
-		fn := c.getInterfaceInvokeWrapper(f)
+		if isAnonymous(typ) && llvmFn.IsDeclaration() {
+			// Inline types may also have methods when they embed interface
+			// types with methods. Example: struct{ error }
+			irbuilder := c.ctx.NewBuilder()
+			defer irbuilder.Dispose()
+			c.createFunction(irbuilder, fn, llvmFn)
+		}
+		wrapper := c.getInterfaceInvokeWrapper(fn, llvmFn)
 		methodInfo := llvm.ConstNamedStruct(interfaceMethodInfoType, []llvm.Value{
 			signatureGlobal,
-			llvm.ConstPtrToInt(fn, c.uintptrType),
+			llvm.ConstPtrToInt(wrapper, c.uintptrType),
 		})
 		methods[i] = methodInfo
 	}
@@ -303,7 +310,7 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 // external *i8 indicating the indicating the signature of this method. It is
 // used during the interface lowering pass.
 func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
-	signature := ir.MethodSignature(method)
+	signature := methodSignature(method)
 	signatureGlobal := c.mod.NamedGlobal("func " + signature)
 	if signatureGlobal.IsNil() {
 		signatureGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), "func "+signature)
@@ -357,8 +364,8 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	// value.
 
 	prevBlock := b.GetInsertBlock()
-	okBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.ok")
-	nextBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.next")
+	okBlock := b.ctx.AddBasicBlock(b.llvmFn, "typeassert.ok")
+	nextBlock := b.ctx.AddBasicBlock(b.llvmFn, "typeassert.next")
 	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
 	b.CreateCondBr(commaOk, okBlock, nextBlock)
 
@@ -436,8 +443,8 @@ func (b *builder) getInvokeCall(instr *ssa.CallCommon) (llvm.Value, []llvm.Value
 // value, dereferences or unpacks it if necessary, and calls the real method.
 // If the method to wrap has a pointer receiver, no wrapping is necessary and
 // the function is returned directly.
-func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
-	wrapperName := f.LinkName() + "$invoke"
+func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llvm.Value) llvm.Value {
+	wrapperName := llvmFn.Name() + "$invoke"
 	wrapper := c.mod.NamedFunction(wrapperName)
 	if !wrapper.IsNil() {
 		// Wrapper already created. Return it directly.
@@ -445,7 +452,7 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	}
 
 	// Get the expanded receiver type.
-	receiverType := c.getLLVMType(f.Params[0].Type())
+	receiverType := c.getLLVMType(fn.Params[0].Type())
 	var expandedReceiverType []llvm.Type
 	for _, info := range expandFormalParamType(receiverType, "", nil) {
 		expandedReceiverType = append(expandedReceiverType, info.llvmType)
@@ -457,15 +464,15 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 		// Casting a function signature to a different signature and calling it
 		// with a receiver pointer bitcasted to *i8 (as done in calls on an
 		// interface) is hopefully a safe (defined) operation.
-		return f.LLVMFn
+		return llvmFn
 	}
 
 	// create wrapper function
-	fnType := f.LLVMFn.Type().ElementType()
+	fnType := llvmFn.Type().ElementType()
 	paramTypes := append([]llvm.Type{c.i8ptrType}, fnType.ParamTypes()[len(expandedReceiverType):]...)
 	wrapFnType := llvm.FunctionType(fnType.ReturnType(), paramTypes, false)
 	wrapper = llvm.AddFunction(c.mod, wrapperName, wrapFnType)
-	if f.LLVMFn.LastParam().Name() == "parentHandle" {
+	if llvmFn.LastParam().Name() == "parentHandle" {
 		wrapper.LastParam().SetName("parentHandle")
 	}
 
@@ -481,8 +488,8 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 
 	// add debug info if needed
 	if c.Debug() {
-		pos := c.ir.Program.Fset.Position(f.Pos())
-		difunc := c.attachDebugInfoRaw(f, wrapper, "$invoke", pos.Filename, pos.Line)
+		pos := c.program.Fset.Position(fn.Pos())
+		difunc := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
 		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 	}
 
@@ -492,13 +499,72 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 
 	receiverValue := b.emitPointerUnpack(wrapper.Param(0), []llvm.Type{receiverType})[0]
 	params := append(b.expandFormalParam(receiverValue), wrapper.Params()[1:]...)
-	if f.LLVMFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
-		b.CreateCall(f.LLVMFn, params, "")
+	if llvmFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
+		b.CreateCall(llvmFn, params, "")
 		b.CreateRetVoid()
 	} else {
-		ret := b.CreateCall(f.LLVMFn, params, "ret")
+		ret := b.CreateCall(llvmFn, params, "ret")
 		b.CreateRet(ret)
 	}
 
 	return wrapper
 }
+
+// isAnonymous returns true if (and only if) this is an anonymous type: one that
+// is created inline. It can have methods if it embeds a type with methods.
+func isAnonymous(typ types.Type) bool {
+	if t, ok := typ.(*types.Pointer); ok {
+		typ = t.Elem()
+	}
+	if _, ok := typ.(*types.Named); !ok {
+		return true
+	}
+	return false
+}
+
+// methodSignature creates a readable version of a method signature (including
+// the function name, excluding the receiver name). This string is used
+// internally to match interfaces and to call the correct method on an
+// interface. Examples:
+//
+//     String() string
+//     Read([]byte) (int, error)
+func methodSignature(method *types.Func) string {
+	return method.Name() + signature(method.Type().(*types.Signature))
+}
+
+// Make a readable version of a function (pointer) signature.
+// Examples:
+//
+//     () string
+//     (string, int) (int, error)
+func signature(sig *types.Signature) string {
+	s := ""
+	if sig.Params().Len() == 0 {
+		s += "()"
+	} else {
+		s += "("
+		for i := 0; i < sig.Params().Len(); i++ {
+			if i > 0 {
+				s += ", "
+			}
+			s += sig.Params().At(i).Type().String()
+		}
+		s += ")"
+	}
+	if sig.Results().Len() == 0 {
+		// keep as-is
+	} else if sig.Results().Len() == 1 {
+		s += " " + sig.Results().At(0).Type().String()
+	} else {
+		s += " ("
+		for i := 0; i < sig.Results().Len(); i++ {
+			if i > 0 {
+				s += ", "
+			}
+			s += sig.Results().At(i).Type().String()
+		}
+		s += ")"
+	}
+	return s
+}

compiler/interrupt.go

@@ -39,7 +39,7 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 
 	// Create a new global of type runtime/interrupt.handle. Globals of this
 	// type are lowered in the interrupt lowering pass.
-	globalType := b.ir.Program.ImportedPackage("runtime/interrupt").Type("handle").Type()
+	globalType := b.program.ImportedPackage("runtime/interrupt").Type("handle").Type()
 	globalLLVMType := b.getLLVMType(globalType)
 	globalName := "runtime/interrupt.$interrupt" + strconv.FormatInt(id.Int64(), 10)
 	if global := b.mod.NamedGlobal(globalName); !global.IsNil() {
@@ -56,7 +56,7 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 
 	// Add debug info to the interrupt global.
 	if b.Debug() {
-		pos := b.ir.Program.Fset.Position(instr.Pos())
+		pos := b.program.Fset.Position(instr.Pos())
 		diglobal := b.dibuilder.CreateGlobalVariableExpression(b.getDIFile(pos.Filename), llvm.DIGlobalVariableExpression{
 			Name:        "interrupt" + strconv.FormatInt(id.Int64(), 10),
 			LinkageName: globalName,

compiler/mkruntimetypes.go

@@ -0,0 +1,344 @@
+// +build none
+
+// This file generates runtimetypes.go from the AST of the TinyGo runtime
+// package. This type information is necessary to avoid having to compile the
+// runtime to compile any package.
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// The list of runtime types known by the compiler.
+var runtimeTypes = []string{
+	// panic, recover
+	"_defer",
+	// strings
+	"_string", "stringIterator",
+	// map
+	"hashmap", "hashmapBucket", "hashmapIterator",
+	// channel
+	"channel", "channelBlockedList", "chanSelectState",
+	// interface
+	"_interface", "interfaceMethodInfo", "typecodeID", "structField", "typeInInterface",
+	// func
+	"funcValue", "funcValueWithSignature",
+}
+
+// The list of runtime calls known to the compiler.
+var runtimeCalls = []string{
+	// panic, recover
+	"_panic", "_recover",
+	"nilPanic", "lookupPanic", "slicePanic", "chanMakePanic", "negativeShiftPanic",
+	// string
+	"stringEqual", "stringLess",
+	"stringConcat",
+	"stringFromBytes", "stringToBytes",
+	"stringFromRunes", "stringToRunes",
+	"stringFromUnicode",
+	"stringNext",
+	// complex
+	"complex64div", "complex128div",
+	// slice
+	"sliceAppend", "sliceCopy",
+	// memory
+	"alloc", "trackPointer",
+	// print builtin
+	"printbool",
+	"printint8", "printuint8",
+	"printint16", "printuint16",
+	"printint32", "printuint32",
+	"printint64", "printuint64",
+	"printfloat32", "printfloat64",
+	"printcomplex64", "printcomplex128",
+	"printstring", "printspace", "printnl",
+	"printptr", "printmap", "printitf",
+	// hashmap
+	"hashmapMake", "hashmapLen", "hashmapNext",
+	"hashmapStringGet", "hashmapStringSet", "hashmapStringDelete",
+	"hashmapInterfaceGet", "hashmapInterfaceSet", "hashmapInterfaceDelete",
+	"hashmapBinaryGet", "hashmapBinarySet", "hashmapBinaryDelete",
+	// channel, concurrency
+	"tryChanSelect", "chanMake", "chanSend", "chanRecv", "chanClose", "chanSelect",
+	"deadlock",
+	// interface, reflect
+	"interfaceEqual", "interfaceImplements", "interfaceMethod",
+	"typeAssert", "interfaceTypeAssert",
+	// func
+	"getFuncPtr",
+}
+
+// makeDefs generates runtimetypes.go and writes it out after formatting it.
+func makeDefs() error {
+	// Load the runtime package.
+	pkgs, err := packages.Load(&packages.Config{
+		Mode:       packages.NeedSyntax,
+		BuildFlags: []string{"-tags=gc.extalloc"},
+	}, "../src/runtime")
+	if err != nil {
+		return err
+	}
+	if len(pkgs) != 1 {
+		return fmt.Errorf("expected 1 package, got %d", len(pkgs))
+	}
+	runtimePkg := pkgs[0]
+	if len(runtimePkg.Errors) != 0 {
+		return runtimePkg.Errors[0]
+	}
+
+	// Start creating the new Go file.
+	buf := &bytes.Buffer{}
+	buf.WriteString(`// Autogenerated by mkruntimetypes.go, DO NOT EDIT.
+
+package compiler
+
+// This file contains definitions for runtime types and functions, so that the
+// runtime package can be compiled independently of other packages.
+
+import (
+	"go/token"
+	"go/types"
+	"strconv"
+)
+
+// getRuntimeType constructs a new runtime type with the given name. The types
+// constructed here must match the types in the runtime package.
+func (c *compilerContext) getRuntimeType(name string) types.Type {
+	if c.program != nil {
+		return c.program.ImportedPackage("runtime").Type(name).Type()
+	}
+	if typ, ok := c.runtimeTypes[name]; ok {
+		// This type was already created.
+		return typ
+	}
+
+	typeName := types.NewTypeName(token.NoPos, c.runtimePkg, name, nil)
+	named := types.NewNamed(typeName, nil, nil)
+
+	// Make sure recursive types are only defined once.
+	c.runtimeTypes[name] = named
+
+	var fieldTypes []types.Type
+	switch name {
+`)
+	err = makeTypeDefs(buf, runtimePkg)
+	if err != nil {
+		return err
+	}
+	buf.WriteString(`		default:
+		panic("could not find runtime type: runtime." + name)
+	}
+
+	// Create the named struct type.
+	var fields []*types.Var
+	for i, t := range fieldTypes {
+		// Field name doesn't matter: this type is only used to create a LLVM
+		// struct type which don't have field names.
+		fields = append(fields, types.NewField(token.NoPos, nil, "field"+strconv.Itoa(i), t, false))
+	}
+	named.SetUnderlying(types.NewStruct(fields, nil))
+	return named
+}
+
+// getRuntimeFuncType constructs a new runtime function signature with the given
+// name. The function signatures constructed here must match the functions in
+// the runtime package.
+func (c *compilerContext) getRuntimeFuncType(name string) *types.Signature {
+	var params []*types.Var
+	addParam := func(name string, typ types.Type) {
+		params = append(params, types.NewParam(token.NoPos, c.runtimePkg, name, typ))
+	}
+	var results []*types.Var
+	addResult := func(typ types.Type) {
+		results = append(results, types.NewParam(token.NoPos, c.runtimePkg, "", typ))
+	}
+	switch name {
+`)
+
+	err = makeFuncDefs(buf, runtimePkg)
+	if err != nil {
+		return err
+	}
+	buf.WriteString(`	default:
+		panic("unknown runtime call: runtime." + name)
+	}
+	return types.NewSignature(nil, types.NewTuple(params...), types.NewTuple(results...), false)
+}
+`)
+
+	source, err := format.Source(buf.Bytes())
+	if err != nil {
+		// Fallback (useful for investigating errors).
+		source = buf.Bytes()
+	}
+	err2 := ioutil.WriteFile("runtimetypes.go", source, 0666)
+	if err2 != nil {
+		return err2 // error from ioutil.WriteFile
+	}
+	return err // error from format.Source (if any)
+}
+
+// makeTypeDefs generates the switch body of the getRuntimeType function.
+func makeTypeDefs(w io.Writer, runtimePkg *packages.Package) error {
+	typeSpecs := map[string]*ast.TypeSpec{}
+	for _, file := range runtimePkg.Syntax {
+		for _, decl := range file.Decls {
+			switch decl := decl.(type) {
+			case *ast.GenDecl:
+				if decl.Tok != token.TYPE {
+					continue
+				}
+				for _, spec := range decl.Specs {
+					typeSpec := spec.(*ast.TypeSpec)
+					typeSpecs[typeSpec.Name.Name] = typeSpec
+				}
+			}
+		}
+	}
+
+	for _, name := range runtimeTypes {
+		typeSpec := typeSpecs[name]
+		if typeSpec == nil {
+			return fmt.Errorf("could not find type: %s", name)
+		}
+		fmt.Fprintf(w, "\tcase %#v:\n", typeSpec.Name.Name)
+		if name == "channelBlockedList" {
+			fmt.Fprintf(w, "\t\ttaskType := types.NewNamed(types.NewTypeName(token.NoPos, c.taskPkg, \"Task\", nil), nil, nil)\n")
+		}
+		fmt.Fprintf(w, "\t\tfieldTypes = []types.Type{\n")
+		for _, field := range typeSpec.Type.(*ast.StructType).Fields.List {
+			fieldType := getTypeFromExpr(field.Type, typeSpec.Name.Name)
+			for _, ident := range field.Names {
+				fmt.Fprintf(w, "\t\t\t%s, // %s\n", fieldType, ident.Name)
+			}
+		}
+		fmt.Fprintf(w, "\t\t}\n")
+	}
+	return nil
+}
+
+// makeFuncDefs generates the switch body of the getRuntimeFuncType function.
+func makeFuncDefs(w io.Writer, runtimePkg *packages.Package) error {
+	functions := map[string]*ast.FuncDecl{}
+	for _, file := range runtimePkg.Syntax {
+		for _, decl := range file.Decls {
+			switch decl := decl.(type) {
+			case *ast.FuncDecl:
+				functions[decl.Name.Name] = decl
+			default:
+			}
+		}
+	}
+
+	for _, name := range runtimeCalls {
+		decl := functions[name]
+		if decl == nil {
+			return fmt.Errorf("could not find function: %s", name)
+		}
+		fmt.Fprintf(w, "\tcase %#v:\n", decl.Name.Name)
+		for _, field := range decl.Type.Params.List {
+			typeString := getTypeFromExpr(field.Type, "")
+			for _, name := range field.Names {
+				fmt.Fprintf(w, "\t\taddParam(%#v, %s)\n", name.Name, typeString)
+			}
+		}
+		if decl.Type.Results != nil {
+			for _, field := range decl.Type.Results.List {
+				typeString := getTypeFromExpr(field.Type, "")
+				for range field.Names {
+					fmt.Fprintf(w, "\t\taddResult(%s)\n", typeString)
+				}
+				if len(field.Names) == 0 {
+					fmt.Fprintf(w, "\t\taddResult(%s)\n", typeString)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// getTypeFromExpr returns a string which is a piece of Go code that constructs
+// the type (as given in ast.Expr) using the go/types package.
+func getTypeFromExpr(typ ast.Expr, currentTypeName string) string {
+	switch typ := typ.(type) {
+	case *ast.Ident:
+		if typ.Name == currentTypeName {
+			// Assume a global named "named" which refers to the currently
+			// created named type.
+			return "named"
+		}
+		switch typ.Name {
+		case "bool", "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr", "float32", "float64", "complex64", "complex128", "string", "byte", "rune":
+			// Built-in types.
+			return fmt.Sprintf("types.Typ[types.%s]", strings.Title(typ.Name))
+		case "chanState":
+			// runtime.chanState is a named type, but that doesn't matter when
+			// generating LLVM IR.
+			return fmt.Sprintf("types.Typ[types.Uint8]")
+		default:
+			// Assume that we can simply get the type recursively.
+			return fmt.Sprintf("c.getRuntimeType(%#v)", typ.Name)
+		}
+	case *ast.StarExpr:
+		return fmt.Sprintf("types.NewPointer(%s)", getTypeFromExpr(typ.X, currentTypeName))
+	case *ast.InterfaceType:
+		if len(typ.Methods.List) != 0 {
+			// Unimplemented: interfaces with methods.
+			return "interface{?}"
+		}
+		return "types.NewInterfaceType(nil, nil)"
+	case *ast.ArrayType:
+		// Slices and arrays. Assume the array length is a numeric constant and
+		// not a Go named constant for example.
+		elementType := getTypeFromExpr(typ.Elt, currentTypeName)
+		if typ.Len == nil {
+			return fmt.Sprintf("types.NewSlice(%s)", elementType)
+		}
+		length := typ.Len.(*ast.BasicLit).Value
+		return fmt.Sprintf("types.NewArray(%s, %s)", elementType, length)
+	case *ast.SelectorExpr:
+		s := typ.X.(*ast.Ident).Name + "." + typ.Sel.Name
+		switch s {
+		case "unsafe.Pointer":
+			return "types.Typ[types.UnsafePointer]"
+		case "task.Task":
+			// Assume there is a variable taskType which refers to the task.Task
+			// structure.
+			return "taskType"
+		default:
+			return fmt.Sprintf("<unknown %s>", s)
+		}
+	case *ast.StructType:
+		// Inline struct type.
+		var fields string
+		for _, field := range typ.Fields.List {
+			fieldType := getTypeFromExpr(field.Type, currentTypeName)
+			for _, ident := range field.Names {
+				fields += fmt.Sprintf("\t\t\ttypes.NewField(token.NoPos, nil, %#v, %s, false),\n", ident.Name, fieldType)
+			}
+		}
+		return fmt.Sprintf("types.NewStruct([]*types.Var{\n%s\t\t}, nil)", fields)
+	default:
+		// Dump the raw typ value, for debugging.
+		return fmt.Sprintf("%#v", typ)
+	}
+}
+
+func main() {
+	err := makeDefs()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "could not create defs:", err)
+		os.Exit(1)
+	}
+}

compiler/runtimetypes.go

@@ -0,0 +1,377 @@
+// Autogenerated by mkruntimetypes.go, DO NOT EDIT.
+
+package compiler
+
+// This file contains definitions for runtime types and functions, so that the
+// runtime package can be compiled independently of other packages.
+
+import (
+	"go/token"
+	"go/types"
+	"strconv"
+)
+
+// getRuntimeType constructs a new runtime type with the given name. The types
+// constructed here must match the types in the runtime package.
+func (c *compilerContext) getRuntimeType(name string) types.Type {
+	if c.program != nil {
+		return c.program.ImportedPackage("runtime").Type(name).Type()
+	}
+	if typ, ok := c.runtimeTypes[name]; ok {
+		// This type was already created.
+		return typ
+	}
+
+	typeName := types.NewTypeName(token.NoPos, c.runtimePkg, name, nil)
+	named := types.NewNamed(typeName, nil, nil)
+
+	// Make sure recursive types are only defined once.
+	c.runtimeTypes[name] = named
+
+	var fieldTypes []types.Type
+	switch name {
+	case "_defer":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr], // callback
+			types.NewPointer(named),  // next
+		}
+	case "_string":
+		fieldTypes = []types.Type{
+			types.NewPointer(types.Typ[types.Byte]), // ptr
+			types.Typ[types.Uintptr],                // length
+		}
+	case "stringIterator":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr], // byteindex
+		}
+	case "hashmap":
+		fieldTypes = []types.Type{
+			types.NewPointer(named),        // next
+			types.Typ[types.UnsafePointer], // buckets
+			types.Typ[types.Uintptr],       // count
+			types.Typ[types.Uint8],         // keySize
+			types.Typ[types.Uint8],         // valueSize
+			types.Typ[types.Uint8],         // bucketBits
+		}
+	case "hashmapBucket":
+		fieldTypes = []types.Type{
+			types.NewArray(types.Typ[types.Uint8], 8), // tophash
+			types.NewPointer(named),                   // next
+		}
+	case "hashmapIterator":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr],                            // bucketNumber
+			types.NewPointer(c.getRuntimeType("hashmapBucket")), // bucket
+			types.Typ[types.Uint8],                              // bucketIndex
+		}
+	case "channel":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr],                                 // elementSize
+			types.Typ[types.Uintptr],                                 // bufSize
+			types.Typ[types.Uint8],                                   // state
+			types.NewPointer(c.getRuntimeType("channelBlockedList")), // blocked
+			types.Typ[types.Uintptr],                                 // bufHead
+			types.Typ[types.Uintptr],                                 // bufTail
+			types.Typ[types.Uintptr],                                 // bufUsed
+			types.Typ[types.UnsafePointer],                           // buf
+		}
+	case "channelBlockedList":
+		taskType := types.NewNamed(types.NewTypeName(token.NoPos, c.taskPkg, "Task", nil), nil, nil)
+		fieldTypes = []types.Type{
+			types.NewPointer(named),                               // next
+			types.NewPointer(taskType),                            // t
+			types.NewPointer(c.getRuntimeType("chanSelectState")), // s
+			types.NewSlice(named),                                 // allSelectOps
+		}
+	case "chanSelectState":
+		fieldTypes = []types.Type{
+			types.NewPointer(c.getRuntimeType("channel")), // ch
+			types.Typ[types.UnsafePointer],                // value
+		}
+	case "_interface":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr],       // typecode
+			types.Typ[types.UnsafePointer], // value
+		}
+	case "interfaceMethodInfo":
+		fieldTypes = []types.Type{
+			types.NewPointer(types.Typ[types.Uint8]), // signature
+			types.Typ[types.Uintptr],                 // funcptr
+		}
+	case "typecodeID":
+		fieldTypes = []types.Type{
+			types.NewPointer(named),  // references
+			types.Typ[types.Uintptr], // length
+		}
+	case "structField":
+		fieldTypes = []types.Type{
+			types.NewPointer(c.getRuntimeType("typecodeID")), // typecode
+			types.NewPointer(types.Typ[types.Uint8]),         // name
+			types.NewPointer(types.Typ[types.Uint8]),         // tag
+			types.Typ[types.Bool],                            // embedded
+		}
+	case "typeInInterface":
+		fieldTypes = []types.Type{
+			types.NewPointer(c.getRuntimeType("typecodeID")),          // typecode
+			types.NewPointer(c.getRuntimeType("interfaceMethodInfo")), // methodSet
+		}
+	case "funcValue":
+		fieldTypes = []types.Type{
+			types.Typ[types.UnsafePointer], // context
+			types.Typ[types.Uintptr],       // id
+		}
+	case "funcValueWithSignature":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr],                         // funcPtr
+			types.NewPointer(c.getRuntimeType("typecodeID")), // signature
+		}
+	default:
+		panic("could not find runtime type: runtime." + name)
+	}
+
+	// Create the named struct type.
+	var fields []*types.Var
+	for i, t := range fieldTypes {
+		// Field name doesn't matter: this type is only used to create a LLVM
+		// struct type which don't have field names.
+		fields = append(fields, types.NewField(token.NoPos, nil, "field"+strconv.Itoa(i), t, false))
+	}
+	named.SetUnderlying(types.NewStruct(fields, nil))
+	return named
+}
+
+// getRuntimeFuncType constructs a new runtime function signature with the given
+// name. The function signatures constructed here must match the functions in
+// the runtime package.
+func (c *compilerContext) getRuntimeFuncType(name string) *types.Signature {
+	var params []*types.Var
+	addParam := func(name string, typ types.Type) {
+		params = append(params, types.NewParam(token.NoPos, c.runtimePkg, name, typ))
+	}
+	var results []*types.Var
+	addResult := func(typ types.Type) {
+		results = append(results, types.NewParam(token.NoPos, c.runtimePkg, "", typ))
+	}
+	switch name {
+	case "_panic":
+		addParam("message", types.NewInterfaceType(nil, nil))
+	case "_recover":
+		addResult(types.NewInterfaceType(nil, nil))
+	case "nilPanic":
+	case "lookupPanic":
+	case "slicePanic":
+	case "chanMakePanic":
+	case "negativeShiftPanic":
+	case "stringEqual":
+		addParam("x", types.Typ[types.String])
+		addParam("y", types.Typ[types.String])
+		addResult(types.Typ[types.Bool])
+	case "stringLess":
+		addParam("x", types.Typ[types.String])
+		addParam("y", types.Typ[types.String])
+		addResult(types.Typ[types.Bool])
+	case "stringConcat":
+		addParam("x", c.getRuntimeType("_string"))
+		addParam("y", c.getRuntimeType("_string"))
+		addResult(c.getRuntimeType("_string"))
+	case "stringFromBytes":
+		addParam("x", types.NewStruct([]*types.Var{
+			types.NewField(token.NoPos, nil, "ptr", types.NewPointer(types.Typ[types.Byte]), false),
+			types.NewField(token.NoPos, nil, "len", types.Typ[types.Uintptr], false),
+			types.NewField(token.NoPos, nil, "cap", types.Typ[types.Uintptr], false),
+		}, nil))
+		addResult(c.getRuntimeType("_string"))
+	case "stringToBytes":
+		addParam("x", c.getRuntimeType("_string"))
+		addResult(types.NewStruct([]*types.Var{
+			types.NewField(token.NoPos, nil, "ptr", types.NewPointer(types.Typ[types.Byte]), false),
+			types.NewField(token.NoPos, nil, "len", types.Typ[types.Uintptr], false),
+			types.NewField(token.NoPos, nil, "cap", types.Typ[types.Uintptr], false),
+		}, nil))
+	case "stringFromRunes":
+		addParam("runeSlice", types.NewSlice(types.Typ[types.Rune]))
+		addResult(c.getRuntimeType("_string"))
+	case "stringToRunes":
+		addParam("s", types.Typ[types.String])
+		addResult(types.NewSlice(types.Typ[types.Rune]))
+	case "stringFromUnicode":
+		addParam("x", types.Typ[types.Rune])
+		addResult(c.getRuntimeType("_string"))
+	case "stringNext":
+		addParam("s", types.Typ[types.String])
+		addParam("it", types.NewPointer(c.getRuntimeType("stringIterator")))
+		addResult(types.Typ[types.Bool])
+		addResult(types.Typ[types.Int])
+		addResult(types.Typ[types.Rune])
+	case "complex64div":
+		addParam("n", types.Typ[types.Complex64])
+		addParam("m", types.Typ[types.Complex64])
+		addResult(types.Typ[types.Complex64])
+	case "complex128div":
+		addParam("n", types.Typ[types.Complex128])
+		addParam("m", types.Typ[types.Complex128])
+		addResult(types.Typ[types.Complex128])
+	case "sliceAppend":
+		addParam("srcBuf", types.Typ[types.UnsafePointer])
+		addParam("elemsBuf", types.Typ[types.UnsafePointer])
+		addParam("srcLen", types.Typ[types.Uintptr])
+		addParam("srcCap", types.Typ[types.Uintptr])
+		addParam("elemsLen", types.Typ[types.Uintptr])
+		addParam("elemSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.UnsafePointer])
+		addResult(types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Uintptr])
+	case "sliceCopy":
+		addParam("dst", types.Typ[types.UnsafePointer])
+		addParam("src", types.Typ[types.UnsafePointer])
+		addParam("dstLen", types.Typ[types.Uintptr])
+		addParam("srcLen", types.Typ[types.Uintptr])
+		addParam("elemSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Int])
+	case "alloc":
+		addParam("size", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.UnsafePointer])
+	case "trackPointer":
+		addParam("ptr", types.Typ[types.UnsafePointer])
+	case "printbool":
+		addParam("b", types.Typ[types.Bool])
+	case "printint8":
+		addParam("n", types.Typ[types.Int8])
+	case "printuint8":
+		addParam("n", types.Typ[types.Uint8])
+	case "printint16":
+		addParam("n", types.Typ[types.Int16])
+	case "printuint16":
+		addParam("n", types.Typ[types.Uint16])
+	case "printint32":
+		addParam("n", types.Typ[types.Int32])
+	case "printuint32":
+		addParam("n", types.Typ[types.Uint32])
+	case "printint64":
+		addParam("n", types.Typ[types.Int64])
+	case "printuint64":
+		addParam("n", types.Typ[types.Uint64])
+	case "printfloat32":
+		addParam("v", types.Typ[types.Float32])
+	case "printfloat64":
+		addParam("v", types.Typ[types.Float64])
+	case "printcomplex64":
+		addParam("c", types.Typ[types.Complex64])
+	case "printcomplex128":
+		addParam("c", types.Typ[types.Complex128])
+	case "printstring":
+		addParam("s", types.Typ[types.String])
+	case "printspace":
+	case "printnl":
+	case "printptr":
+		addParam("ptr", types.Typ[types.Uintptr])
+	case "printmap":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+	case "printitf":
+		addParam("msg", types.NewInterfaceType(nil, nil))
+	case "hashmapMake":
+		addParam("keySize", types.Typ[types.Uint8])
+		addParam("valueSize", types.Typ[types.Uint8])
+		addParam("sizeHint", types.Typ[types.Uintptr])
+		addResult(types.NewPointer(c.getRuntimeType("hashmap")))
+	case "hashmapLen":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addResult(types.Typ[types.Int])
+	case "hashmapNext":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("it", types.NewPointer(c.getRuntimeType("hashmapIterator")))
+		addParam("key", types.Typ[types.UnsafePointer])
+		addParam("value", types.Typ[types.UnsafePointer])
+		addResult(types.Typ[types.Bool])
+	case "hashmapStringGet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.String])
+		addParam("value", types.Typ[types.UnsafePointer])
+		addParam("valueSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "hashmapStringSet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.String])
+		addParam("value", types.Typ[types.UnsafePointer])
+	case "hashmapStringDelete":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.String])
+	case "hashmapInterfaceGet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.NewInterfaceType(nil, nil))
+		addParam("value", types.Typ[types.UnsafePointer])
+		addParam("valueSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "hashmapInterfaceSet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.NewInterfaceType(nil, nil))
+		addParam("value", types.Typ[types.UnsafePointer])
+	case "hashmapInterfaceDelete":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.NewInterfaceType(nil, nil))
+	case "hashmapBinaryGet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.UnsafePointer])
+		addParam("value", types.Typ[types.UnsafePointer])
+		addParam("valueSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "hashmapBinarySet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.UnsafePointer])
+		addParam("value", types.Typ[types.UnsafePointer])
+	case "hashmapBinaryDelete":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.UnsafePointer])
+	case "tryChanSelect":
+		addParam("recvbuf", types.Typ[types.UnsafePointer])
+		addParam("states", types.NewSlice(c.getRuntimeType("chanSelectState")))
+		addResult(types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "chanMake":
+		addParam("elementSize", types.Typ[types.Uintptr])
+		addParam("bufSize", types.Typ[types.Uintptr])
+		addResult(types.NewPointer(c.getRuntimeType("channel")))
+	case "chanSend":
+		addParam("ch", types.NewPointer(c.getRuntimeType("channel")))
+		addParam("value", types.Typ[types.UnsafePointer])
+	case "chanRecv":
+		addParam("ch", types.NewPointer(c.getRuntimeType("channel")))
+		addParam("value", types.Typ[types.UnsafePointer])
+		addResult(types.Typ[types.Bool])
+	case "chanClose":
+		addParam("ch", types.NewPointer(c.getRuntimeType("channel")))
+	case "chanSelect":
+		addParam("recvbuf", types.Typ[types.UnsafePointer])
+		addParam("states", types.NewSlice(c.getRuntimeType("chanSelectState")))
+		addParam("ops", types.NewSlice(c.getRuntimeType("channelBlockedList")))
+		addResult(types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "deadlock":
+	case "interfaceEqual":
+		addParam("x", types.NewInterfaceType(nil, nil))
+		addParam("y", types.NewInterfaceType(nil, nil))
+		addResult(types.Typ[types.Bool])
+	case "interfaceImplements":
+		addParam("typecode", types.Typ[types.Uintptr])
+		addParam("interfaceMethodSet", types.NewPointer(types.NewPointer(types.Typ[types.Uint8])))
+		addResult(types.Typ[types.Bool])
+	case "interfaceMethod":
+		addParam("typecode", types.Typ[types.Uintptr])
+		addParam("interfaceMethodSet", types.NewPointer(types.NewPointer(types.Typ[types.Uint8])))
+		addParam("signature", types.NewPointer(types.Typ[types.Uint8]))
+		addResult(types.Typ[types.Uintptr])
+	case "typeAssert":
+		addParam("actualType", types.Typ[types.Uintptr])
+		addParam("assertedType", types.NewPointer(c.getRuntimeType("typecodeID")))
+		addResult(types.Typ[types.Bool])
+	case "interfaceTypeAssert":
+		addParam("ok", types.Typ[types.Bool])
+	case "getFuncPtr":
+		addParam("val", c.getRuntimeType("funcValue"))
+		addParam("signature", types.NewPointer(c.getRuntimeType("typecodeID")))
+		addResult(types.Typ[types.Uintptr])
+	default:
+		panic("unknown runtime call: runtime." + name)
+	}
+	return types.NewSignature(nil, types.NewTuple(params...), types.NewTuple(results...), false)
+}

compiler/symbol.go

@@ -15,6 +15,208 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
+type inlineType int
+
+// How much to inline.
+const (
+	// Default behavior. The compiler decides for itself whether any given
+	// function will be inlined. Whether any function is inlined depends on the
+	// optimization level.
+	inlineDefault inlineType = iota
+
+	// Inline hint, just like the C inline keyword (signalled using
+	// //go:inline). The compiler will be more likely to inline this function,
+	// but it is not a guarantee.
+	inlineHint
+
+	// Don't inline, just like the GCC noinline attribute. Signalled using
+	// //go:noinline.
+	inlineNone
+)
+
+// functionInfo contains some information about a function or method. In
+// particular, it contains information obtained from pragmas.
+//
+// The linkName value contains a valid link name, even though //go:linkname is
+// not present.
+type functionInfo struct {
+	linkName string     // go:linkname, go:export
+	module   string     // go:wasm-module
+	exported bool       // go:export
+	nobounds bool       // go:nobounds
+	inline   inlineType // go:inline
+}
+
+// getFunction returns the LLVM function for the given *ssa.Function, creating
+// it if needed. It can later be filled with compilerContext.createFunction().
+func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
+	info := c.getFunctionInfo(fn)
+	return c.getFunctionRaw(fn.Signature, info)
+}
+
+func (c *compilerContext) getFunctionRaw(sig *types.Signature, info functionInfo) llvm.Value {
+	llvmFn := c.mod.NamedFunction(info.linkName)
+	if !llvmFn.IsNil() {
+		return llvmFn
+	}
+
+	var retType llvm.Type
+	if sig.Results() == nil {
+		retType = c.ctx.VoidType()
+	} else if sig.Results().Len() == 1 {
+		retType = c.getLLVMType(sig.Results().At(0).Type())
+	} else {
+		results := make([]llvm.Type, 0, sig.Results().Len())
+		for i := 0; i < sig.Results().Len(); i++ {
+			results = append(results, c.getLLVMType(sig.Results().At(i).Type()))
+		}
+		retType = c.ctx.StructType(results, false)
+	}
+
+	var paramInfos []paramInfo
+	params := []*types.Var{}
+	if sig.Recv() != nil {
+		params = append(params, sig.Recv())
+	}
+	for i := 0; i < sig.Params().Len(); i++ {
+		params = append(params, sig.Params().At(i))
+	}
+	for _, param := range params {
+		paramType := c.getLLVMType(param.Type())
+		paramFragmentInfos := expandFormalParamType(paramType, param.Name(), param.Type())
+		paramInfos = append(paramInfos, paramFragmentInfos...)
+	}
+
+	// Add an extra parameter as the function context. This context is used in
+	// closures and bound methods, but should be optimized away when not used.
+	if !info.exported {
+		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "context", flags: 0})
+		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "parentHandle", flags: 0})
+	}
+
+	var paramTypes []llvm.Type
+	for _, info := range paramInfos {
+		paramTypes = append(paramTypes, info.llvmType)
+	}
+
+	fnType := llvm.FunctionType(retType, paramTypes, false)
+	llvmFn = llvm.AddFunction(c.mod, info.linkName, fnType)
+
+	dereferenceableOrNullKind := llvm.AttributeKindID("dereferenceable_or_null")
+	for i, info := range paramInfos {
+		if info.flags&paramIsDeferenceableOrNull == 0 {
+			continue
+		}
+		if info.llvmType.TypeKind() == llvm.PointerTypeKind {
+			el := info.llvmType.ElementType()
+			size := c.targetData.TypeAllocSize(el)
+			if size == 0 {
+				// dereferenceable_or_null(0) appears to be illegal in LLVM.
+				continue
+			}
+			dereferenceableOrNull := c.ctx.CreateEnumAttribute(dereferenceableOrNullKind, size)
+			llvmFn.AddAttributeAtIndex(i+1, dereferenceableOrNull)
+		}
+	}
+
+	// External/exported functions may not retain pointer values.
+	// https://golang.org/cmd/cgo/#hdr-Passing_pointers
+	if info.exported {
+		// Set the wasm-import-module attribute if the function's module is set.
+		if info.module != "" {
+			wasmImportModuleAttr := c.ctx.CreateStringAttribute("wasm-import-module", info.module)
+			llvmFn.AddFunctionAttr(wasmImportModuleAttr)
+		}
+		nocaptureKind := llvm.AttributeKindID("nocapture")
+		nocapture := c.ctx.CreateEnumAttribute(nocaptureKind, 0)
+		for i, typ := range paramTypes {
+			if typ.TypeKind() == llvm.PointerTypeKind {
+				llvmFn.AddAttributeAtIndex(i+1, nocapture)
+			}
+		}
+	}
+	return llvmFn
+}
+
+// getFunctionInfo returns information about a function that is not directly
+// present in *ssa.Function, such as the link name and whether it should be
+// exported.
+func (c *compilerContext) getFunctionInfo(f *ssa.Function) functionInfo {
+	info := functionInfo{}
+	if strings.HasPrefix(f.Name(), "C.") {
+		// Created by CGo: such a name cannot be created by regular C code.
+		info.linkName = f.Name()[2:]
+		info.exported = true
+	} else {
+		// Pick the default linkName.
+		info.linkName = f.RelString(nil)
+		// Check for //go: pragmas, which may change the link name (among
+		// others).
+		info.parsePragmas(f)
+	}
+	return info
+}
+
+// parsePragmas is used by getFunctionInfo to parse function pragmas such as
+// //export or //go:noinline.
+func (info *functionInfo) parsePragmas(f *ssa.Function) {
+	// Parse compiler directives in the preceding comments.
+	if f.Syntax() == nil {
+		return
+	}
+	if decl, ok := f.Syntax().(*ast.FuncDecl); ok && decl.Doc != nil {
+		for _, comment := range decl.Doc.List {
+			text := comment.Text
+			if strings.HasPrefix(text, "//export ") {
+				// Rewrite '//export' to '//go:export' for compatibility with
+				// gc.
+				text = "//go:" + text[2:]
+			}
+			if !strings.HasPrefix(text, "//go:") {
+				continue
+			}
+			parts := strings.Fields(text)
+			switch parts[0] {
+			case "//go:export":
+				if len(parts) != 2 {
+					continue
+				}
+				info.linkName = parts[1]
+				info.exported = true
+			case "//go:wasm-module":
+				// Alternative comment for setting the import module.
+				if len(parts) != 2 {
+					continue
+				}
+				info.module = parts[1]
+			case "//go:inline":
+				info.inline = inlineHint
+			case "//go:noinline":
+				info.inline = inlineNone
+			case "//go:linkname":
+				if len(parts) != 3 || parts[1] != f.Name() {
+					continue
+				}
+				// Only enable go:linkname when the package imports "unsafe".
+				// This is a slightly looser requirement than what gc uses: gc
+				// requires the file to import "unsafe", not the package as a
+				// whole.
+				if hasUnsafeImport(f.Pkg.Pkg) {
+					info.linkName = parts[2]
+				}
+			case "//go:nobounds":
+				// Skip bounds checking in this function. Useful for some
+				// runtime functions.
+				// This is somewhat dangerous and thus only imported in packages
+				// that import unsafe.
+				if hasUnsafeImport(f.Pkg.Pkg) {
+					info.nobounds = true
+				}
+			}
+		}
+	}
+}
+
 // globalInfo contains some information about a specific global. By default,
 // linkName is equal to .RelString(nil) on a global and extern is false, but for
 // some symbols this is different (due to //go:extern for example).
@@ -86,7 +288,7 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 			// Add debug info.
 			// TODO: this should be done for every global in the program, not just
 			// the ones that are referenced from some code.
-			pos := c.ir.Program.Fset.Position(g.Pos())
+			pos := c.program.Fset.Position(g.Pos())
 			diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[pos.Filename], llvm.DIGlobalVariableExpression{
 				Name:        g.RelString(nil),
 				LinkageName: info.linkName,
@@ -145,3 +347,23 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 		}
 	}
 }
+
+// Get all methods of a type.
+func getAllMethods(prog *ssa.Program, typ types.Type) []*types.Selection {
+	ms := prog.MethodSets.MethodSet(typ)
+	methods := make([]*types.Selection, ms.Len())
+	for i := 0; i < ms.Len(); i++ {
+		methods[i] = ms.At(i)
+	}
+	return methods
+}
+
+// Return true if this package imports "unsafe", false otherwise.
+func hasUnsafeImport(pkg *types.Package) bool {
+	for _, imp := range pkg.Imports() {
+		if imp == types.Unsafe {
+			return true
+		}
+	}
+	return false
+}

compiler/testdata/basic.go

@@ -0,0 +1,13 @@
+package main
+
+func add(x, y int) int {
+	return x + y
+}
+
+func stringEqual(s string) bool {
+	return s == "s"
+}
+
+func closeChan(ch chan int) {
+	close(ch)
+}

compiler/testdata/basic.ll

@@ -0,0 +1,41 @@
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "armv7m-none-eabi"
+
+%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
+%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
+%"internal/task.Task" = type opaque
+%runtime.chanSelectState = type { %runtime.channel*, i8* }
+%runtime._string = type { i8*, i32 }
+
+@"main.stringEqual$string" = internal unnamed_addr constant [1 x i8] c"s"
+
+define internal i32 @main.add(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = add i32 %x, %y
+  ret i32 %0
+}
+
+define internal void @main.closeChan(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
+  ret void
+}
+
+declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
+
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  ret void
+}
+
+define internal i1 @main.stringEqual(i8* %s.data, i32 %s.len, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = insertvalue %runtime._string zeroinitializer, i8* %s.data, 0
+  %1 = insertvalue %runtime._string %0, i32 %s.len, 1
+  %2 = extractvalue %runtime._string %1, 0
+  %3 = extractvalue %runtime._string %1, 1
+  %4 = call i1 @runtime.stringEqual(i8* %2, i32 %3, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @"main.stringEqual$string", i32 0, i32 0), i32 1, i8* undef, i8* null)
+  ret i1 %4
+}
+
+declare i1 @runtime.stringEqual(i8*, i32, i8*, i32, i8*, i8*)

go.mod

@@ -4,11 +4,10 @@ go 1.11
 
 require (
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
-	github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac
-	github.com/chromedp/chromedp v0.5.3
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
-	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
+	github.com/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46
 	go.bug.st/serial v1.0.0
 	golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2
-	tinygo.org/x/go-llvm v0.0.0-20200503224449-70c558526021
+	google.golang.org/appengine v1.4.0 // indirect
+	tinygo.org/x/go-llvm v0.0.0-20200401165421-8d120882fc7a
 )

go.sum

@@ -1,26 +1,13 @@
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2 h1:oMCHnXa6CCCafdPDbMh/lWRhRByN0VFLvv+g+ayx1SI=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI=
-github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac h1:T7V5BXqnYd55Hj/g5uhDYumg9Fp3rMTS6bykYtTIFX4=
-github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac/go.mod h1:PfAWWKJqjlGFYJEidUM6aVIWPr0EpobeyVWEEmplX7g=
-github.com/chromedp/chromedp v0.5.3 h1:F9LafxmYpsQhWQBdCs+6Sret1zzeeFyHS5LkRF//Ffg=
-github.com/chromedp/chromedp v0.5.3/go.mod h1:YLdPtndaHQ4rCpSpBG+IPpy9JvX0VD+7aaLxYgYj28w=
 github.com/creack/goselect v0.1.1 h1:tiSSgKE1eJtxs1h/VgGQWuXUP0YS4CDIFMp6vaI1ls0=
 github.com/creack/goselect v0.1.1/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
-github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
-github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf h1:7+FW5aGwISbqUtkfmIpZJGRgNFg2ioYPvFaUxdqpDsg=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf/go.mod h1:RpwtwJQFrIEPstU94h88MWPXP2ektJZ8cZ0YntAmXiE=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08 h1:V0an7KRw92wmJysvFvtqtKMAPmvS5O0jtB0nYo6t+gs=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08/go.mod h1:dFWs1zEqDjFtnBXsd1vPOZaLsESovai349994nHx3e0=
-github.com/mailru/easyjson v0.7.0 h1:aizVhC/NAAcKWb+5QsU1iNOZb4Yws5UO2I+aIprQITM=
-github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
-github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892 h1:6J+qramlHVLmiBOgRiBOnQkno8uprqG6YFFQTt6uYIw=
-github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892/go.mod h1:Pb6XcsXyropB9LNHhnqaknG/vEwYztLkQzVCHv8sQ3M=
+github.com/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46 h1:wXG2bA8fO7Vv7lLk2PihFMTqmbT173Tje39oKzQ50Mo=
+github.com/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46/go.mod h1:Pb6XcsXyropB9LNHhnqaknG/vEwYztLkQzVCHv8sQ3M=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
@@ -30,21 +17,43 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee h1:WG0RUwxtNT4qqaXX3DPA8zHFNm/D9xaBpxzHt1WcA/E=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 h1:ZBzSG/7F4eNKz2L3GE9o300RX0Az1Bw5HF7PDraD+qU=
 golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20190227180812-8dcc6e70cdef h1:ymc9FeDom3RIEA3coKokSllBB1hRcMT0tZ1W3Jf9Ids=
+golang.org/x/tools v0.0.0-20190227180812-8dcc6e70cdef/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2 h1:0sfSpGSa544Fwnbot3Oxq/U6SXqjty6Jy/3wRhVS7ig=
 golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-tinygo.org/x/go-llvm v0.0.0-20200503224449-70c558526021 h1:d8T98WXGjrTgDmMXgxa6nb9EAYXGXwnzXygnJl6d+ac=
-tinygo.org/x/go-llvm v0.0.0-20200503224449-70c558526021/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20190224120431-7707ae5d1261 h1:rJS2Hga39YAnm7DE4qrPm6Dr/67EOojL0XPzvbEeBiw=
+tinygo.org/x/go-llvm v0.0.0-20190224120431-7707ae5d1261/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20190818154551-95bc4ffe1add h1:dFjMH1sLhYADg8UQm7DB56B7e+TfvAmWmEZLhyv3r/w=
+tinygo.org/x/go-llvm v0.0.0-20190818154551-95bc4ffe1add/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20191103182207-90b6e4bdc0b9 h1:d6rAX39a3C0pKrY5HcojEGyN8w9ocU0v7X28lC/TRKU=
+tinygo.org/x/go-llvm v0.0.0-20191103182207-90b6e4bdc0b9/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20191103200204-37e93e3f04e2 h1:Q5Hv3e5cLMGkiYwYgZL1Zrv6nb/EY+DJpRWrdO6ws6o=
+tinygo.org/x/go-llvm v0.0.0-20191103200204-37e93e3f04e2/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20191113125529-bad6d01809e8 h1:9Bfvso+tTVQg16UzOA614NaYA4x8vsRBNtd3eBrXwp0=
+tinygo.org/x/go-llvm v0.0.0-20191113125529-bad6d01809e8/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20191124211856-b2db3df3f257 h1:o8VDylrMN7gWemBMu8rEyuogKPhcLTdx5KrUAp9macc=
+tinygo.org/x/go-llvm v0.0.0-20191124211856-b2db3df3f257/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20191215173731-ad71f3d24aae h1:s8J5EyxCkHxXB08UI3gk9W9IS/ekizRvSX+PfZxnAB0=
+tinygo.org/x/go-llvm v0.0.0-20191215173731-ad71f3d24aae/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20200104190746-1ff21df33566 h1:a4y30bTf7U0zDA75v2PTL+XQ2OzJetj19gK8XwQpUNY=
+tinygo.org/x/go-llvm v0.0.0-20200104190746-1ff21df33566/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20200226165415-53522ab6713d h1:mtgZh/e8a3wxneQFuLXoQYO//1mvlki02yZ1JCwMKp4=
+tinygo.org/x/go-llvm v0.0.0-20200226165415-53522ab6713d/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20200401165421-8d120882fc7a h1:Ugje2Lxuv8CFncHzs5W+hWfJvPsM+W4K0zRvzFbLvoE=
+tinygo.org/x/go-llvm v0.0.0-20200401165421-8d120882fc7a/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=

goenv/version.go

@@ -1,68 +0,0 @@
-package goenv
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-// Version of TinyGo.
-// Update this value before release of new version of software.
-const Version = "0.14.0-dev"
-
-// GetGorootVersion returns the major and minor version for a given GOROOT path.
-// If the goroot cannot be determined, (0, 0) is returned.
-func GetGorootVersion(goroot string) (major, minor int, err error) {
-	s, err := GorootVersionString(goroot)
-	if err != nil {
-		return 0, 0, err
-	}
-
-	if s == "" || s[:2] != "go" {
-		return 0, 0, errors.New("could not parse Go version: version does not start with 'go' prefix")
-	}
-
-	parts := strings.Split(s[2:], ".")
-	if len(parts) < 2 {
-		return 0, 0, errors.New("could not parse Go version: version has less than two parts")
-	}
-
-	// Ignore the errors, we don't really handle errors here anyway.
-	var trailing string
-	n, err := fmt.Sscanf(s, "go%d.%d%s", &major, &minor, &trailing)
-	if n == 2 && err == io.EOF {
-		// Means there were no trailing characters (i.e., not an alpha/beta)
-		err = nil
-	}
-	if err != nil {
-		return 0, 0, fmt.Errorf("failed to parse version: %s", err)
-	}
-	return
-}
-
-// GorootVersionString returns the version string as reported by the Go
-// toolchain for the given GOROOT path. It is usually of the form `go1.x.y` but
-// can have some variations (for beta releases, for example).
-func GorootVersionString(goroot string) (string, error) {
-	if data, err := ioutil.ReadFile(filepath.Join(
-		goroot, "src", "runtime", "internal", "sys", "zversion.go")); err == nil {
-
-		r := regexp.MustCompile("const TheVersion = `(.*)`")
-		matches := r.FindSubmatch(data)
-		if len(matches) != 2 {
-			return "", errors.New("Invalid go version output:\n" + string(data))
-		}
-
-		return string(matches[1]), nil
-
-	} else if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
-		return string(data), nil
-
-	} else {
-		return "", err
-	}
-}

interp/frame.go

@@ -283,6 +283,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 					PkgName:   fr.packagePath,
 					KeySize:   int(keySize),
 					ValueSize: int(valueSize),
+					MapType:   inst.Type().ElementType(),
 				}
 			case callee.Name() == "runtime.hashmapStringSet":
 				// set a string key in the map
@@ -350,7 +351,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				global.SetLinkage(llvm.InternalLinkage)
 				global.SetGlobalConstant(true)
 				global.SetUnnamedAddr(true)
-				stringType := fr.Mod.GetTypeByName("runtime._string")
+				stringType := inst.Type()
 				retPtr := llvm.ConstGEP(global, getLLVMIndices(fr.Mod.Context().Int32Type(), []uint32{0, 0}))
 				retLen := llvm.ConstInt(stringType.StructElementTypes()[1], uint64(len(result)), false)
 				ret := llvm.ConstNull(stringType)

interp/values.go

@@ -178,6 +178,8 @@ type MapValue struct {
 	ValueSize  int
 	KeyType    llvm.Type
 	ValueType  llvm.Type
+	MapType    llvm.Type // *%runtime.hashmap
+	keyVariant string
 }
 
 func (v *MapValue) newBucket() llvm.Value {
@@ -221,27 +223,32 @@ func (v *MapValue) Value() llvm.Value {
 		var keyBuf []byte
 		llvmKey := key.Value()
 		llvmValue := v.Values[i].Value()
-		if key.Type().TypeKind() == llvm.StructTypeKind && key.Type().StructName() == "runtime._string" {
+		switch v.keyVariant {
+		case "string":
 			keyPtr := llvm.ConstExtractValue(llvmKey, []uint32{0})
 			keyLen := llvm.ConstExtractValue(llvmKey, []uint32{1})
 			keyPtrVal := v.Eval.getValue(keyPtr)
 			keyBuf = getStringBytes(keyPtrVal, keyLen)
-		} else if key.Type().TypeKind() == llvm.IntegerTypeKind {
-			keyBuf = make([]byte, v.Eval.TargetData.TypeAllocSize(key.Type()))
-			n := key.Value().ZExtValue()
-			for i := range keyBuf {
-				keyBuf[i] = byte(n)
-				n >>= 8
+		case "binary":
+			if key.Type().TypeKind() == llvm.IntegerTypeKind {
+				keyBuf = make([]byte, v.Eval.TargetData.TypeAllocSize(key.Type()))
+				n := key.Value().ZExtValue()
+				for i := range keyBuf {
+					keyBuf[i] = byte(n)
+					n >>= 8
+				}
+			} else if key.Type().TypeKind() == llvm.ArrayTypeKind &&
+				key.Type().ElementType().TypeKind() == llvm.IntegerTypeKind &&
+				key.Type().ElementType().IntTypeWidth() == 8 {
+				keyBuf = make([]byte, v.Eval.TargetData.TypeAllocSize(key.Type()))
+				for i := range keyBuf {
+					keyBuf[i] = byte(llvm.ConstExtractValue(llvmKey, []uint32{uint32(i)}).ZExtValue())
+				}
+			} else {
+				panic("interp: map key type not implemented: " + key.Type().String())
 			}
-		} else if key.Type().TypeKind() == llvm.ArrayTypeKind &&
-			key.Type().ElementType().TypeKind() == llvm.IntegerTypeKind &&
-			key.Type().ElementType().IntTypeWidth() == 8 {
-			keyBuf = make([]byte, v.Eval.TargetData.TypeAllocSize(key.Type()))
-			for i := range keyBuf {
-				keyBuf[i] = byte(llvm.ConstExtractValue(llvmKey, []uint32{uint32(i)}).ZExtValue())
-			}
-		} else {
-			panic("interp: map key type not implemented: " + key.Type().String())
+		default:
+			panic("interp: map key variant: " + v.keyVariant)
 		}
 		hash := v.hash(keyBuf)
 
@@ -291,7 +298,7 @@ func (v *MapValue) Value() llvm.Value {
 
 // Type returns type runtime.hashmap, which is the actual hashmap type.
 func (v *MapValue) Type() llvm.Type {
-	return v.Eval.Mod.GetTypeByName("runtime.hashmap")
+	return v.MapType
 }
 
 func (v *MapValue) IsConstant() bool {
@@ -314,12 +321,30 @@ func (v *MapValue) GetElementPtr(indices []uint32) (Value, error) {
 	return nil, errors.New("interp: GEP on a map")
 }
 
+// setKeyVariant sets the key variant as a result of storing to the hashmap
+// (string, binary, or interface). The way that TinyGo is structured, the key
+// variant is not known until there is a store to the hashmap.
+// The key variant has to be known when lowering the hashmap to its final form,
+// to correctly calculate the hash of a key (for example, a string key must
+// calculate the hash over the string contents).
+func (v *MapValue) setKeyVariant(keyVariant string) {
+	if v.keyVariant == "" {
+		v.keyVariant = keyVariant
+		return
+	}
+	if v.keyVariant != keyVariant {
+		// Valid IR will not cause this panic to occur.
+		panic("MapValue store with inconsistent key type")
+	}
+}
+
 // PutString does a map assign operation, assuming that the map is of type
 // map[string]T.
 func (v *MapValue) PutString(keyBuf, keyLen, valPtr *LocalValue) {
 	if !v.Underlying.IsNil() {
 		panic("map already created")
 	}
+	v.setKeyVariant("string")
 
 	if valPtr.Underlying.Opcode() == llvm.BitCast {
 		valPtr = &LocalValue{v.Eval, valPtr.Underlying.Operand(0)}
@@ -336,9 +361,13 @@ func (v *MapValue) PutString(keyBuf, keyLen, valPtr *LocalValue) {
 		}
 	}
 
-	keyType := v.Eval.Mod.GetTypeByName("runtime._string")
-	v.KeyType = keyType
-	key := llvm.ConstNull(keyType)
+	if v.KeyType.IsNil() {
+		v.KeyType = v.Eval.Mod.Context().StructType([]llvm.Type{
+			keyBuf.Type(),
+			keyLen.Type(),
+		}, false)
+	}
+	key := llvm.ConstNull(v.KeyType)
 	key = llvm.ConstInsertValue(key, keyBuf.Value(), []uint32{0})
 	key = llvm.ConstInsertValue(key, keyLen.Value(), []uint32{1})
 
@@ -352,6 +381,7 @@ func (v *MapValue) PutBinary(keyPtr, valPtr *LocalValue) {
 	if !v.Underlying.IsNil() {
 		panic("map already created")
 	}
+	v.setKeyVariant("binary")
 
 	if valPtr.Underlying.Opcode() == llvm.BitCast {
 		valPtr = &LocalValue{v.Eval, valPtr.Underlying.Operand(0)}

ir/ir.go

@@ -1,271 +0,0 @@
-package ir
-
-import (
-	"go/ast"
-	"go/types"
-	"sort"
-	"strings"
-
-	"github.com/tinygo-org/tinygo/loader"
-	"golang.org/x/tools/go/ssa"
-	"tinygo.org/x/go-llvm"
-)
-
-// This file provides a wrapper around go/ssa values and adds extra
-// functionality to them.
-
-// View on all functions, types, and globals in a program, with analysis
-// results.
-type Program struct {
-	Program       *ssa.Program
-	LoaderProgram *loader.Program
-	mainPkg       *ssa.Package
-	Functions     []*Function
-	functionMap   map[*ssa.Function]*Function
-}
-
-// Function or method.
-type Function struct {
-	*ssa.Function
-	LLVMFn   llvm.Value
-	module   string     // go:wasm-module
-	linkName string     // go:linkname, go:export
-	exported bool       // go:export
-	nobounds bool       // go:nobounds
-	flag     bool       // used by dead code elimination
-	inline   InlineType // go:inline
-}
-
-// Interface type that is at some point used in a type assert (to check whether
-// it implements another interface).
-type Interface struct {
-	Num  int
-	Type *types.Interface
-}
-
-type InlineType int
-
-// How much to inline.
-const (
-	// Default behavior. The compiler decides for itself whether any given
-	// function will be inlined. Whether any function is inlined depends on the
-	// optimization level.
-	InlineDefault InlineType = iota
-
-	// Inline hint, just like the C inline keyword (signalled using
-	// //go:inline). The compiler will be more likely to inline this function,
-	// but it is not a guarantee.
-	InlineHint
-
-	// Don't inline, just like the GCC noinline attribute. Signalled using
-	// //go:noinline.
-	InlineNone
-)
-
-// Create and initialize a new *Program from a *ssa.Program.
-func NewProgram(lprogram *loader.Program) *Program {
-	program := lprogram.LoadSSA()
-	program.Build()
-
-	mainPkg := program.ImportedPackage(lprogram.MainPkg.PkgPath)
-	if mainPkg == nil {
-		panic("could not find main package")
-	}
-	p := &Program{
-		Program:       program,
-		LoaderProgram: lprogram,
-		mainPkg:       mainPkg,
-		functionMap:   make(map[*ssa.Function]*Function),
-	}
-
-	for _, pkg := range lprogram.Sorted() {
-		p.AddPackage(program.ImportedPackage(pkg.PkgPath))
-	}
-
-	return p
-}
-
-// Add a package to this Program. All packages need to be added first before any
-// analysis is done for correct results.
-func (p *Program) AddPackage(pkg *ssa.Package) {
-	memberNames := make([]string, 0)
-	for name := range pkg.Members {
-		memberNames = append(memberNames, name)
-	}
-	sort.Strings(memberNames)
-
-	for _, name := range memberNames {
-		member := pkg.Members[name]
-		switch member := member.(type) {
-		case *ssa.Function:
-			p.addFunction(member)
-		case *ssa.Type:
-			methods := getAllMethods(pkg.Prog, member.Type())
-			if !types.IsInterface(member.Type()) {
-				// named type
-				for _, method := range methods {
-					p.addFunction(pkg.Prog.MethodValue(method))
-				}
-			}
-		case *ssa.Global:
-			// Ignore. Globals are not handled here.
-		case *ssa.NamedConst:
-			// Ignore: these are already resolved.
-		default:
-			panic("unknown member type: " + member.String())
-		}
-	}
-}
-
-func (p *Program) addFunction(ssaFn *ssa.Function) {
-	if _, ok := p.functionMap[ssaFn]; ok {
-		return
-	}
-	f := &Function{Function: ssaFn}
-	f.parsePragmas()
-	p.Functions = append(p.Functions, f)
-	p.functionMap[ssaFn] = f
-
-	for _, anon := range ssaFn.AnonFuncs {
-		p.addFunction(anon)
-	}
-}
-
-// Return true if this package imports "unsafe", false otherwise.
-func hasUnsafeImport(pkg *types.Package) bool {
-	for _, imp := range pkg.Imports() {
-		if imp == types.Unsafe {
-			return true
-		}
-	}
-	return false
-}
-
-func (p *Program) GetFunction(ssaFn *ssa.Function) *Function {
-	return p.functionMap[ssaFn]
-}
-
-func (p *Program) MainPkg() *ssa.Package {
-	return p.mainPkg
-}
-
-// Parse compiler directives in the preceding comments.
-func (f *Function) parsePragmas() {
-	if f.Syntax() == nil {
-		return
-	}
-	if decl, ok := f.Syntax().(*ast.FuncDecl); ok && decl.Doc != nil {
-		for _, comment := range decl.Doc.List {
-			text := comment.Text
-			if strings.HasPrefix(text, "//export ") {
-				// Rewrite '//export' to '//go:export' for compatibility with
-				// gc.
-				text = "//go:" + text[2:]
-			}
-			if !strings.HasPrefix(text, "//go:") {
-				continue
-			}
-			parts := strings.Fields(text)
-			switch parts[0] {
-			case "//go:export":
-				if len(parts) != 2 {
-					continue
-				}
-				f.linkName = parts[1]
-				f.exported = true
-			case "//go:wasm-module":
-				// Alternative comment for setting the import module.
-				if len(parts) != 2 {
-					continue
-				}
-				f.module = parts[1]
-			case "//go:inline":
-				f.inline = InlineHint
-			case "//go:noinline":
-				f.inline = InlineNone
-			case "//go:linkname":
-				if len(parts) != 3 || parts[1] != f.Name() {
-					continue
-				}
-				// Only enable go:linkname when the package imports "unsafe".
-				// This is a slightly looser requirement than what gc uses: gc
-				// requires the file to import "unsafe", not the package as a
-				// whole.
-				if hasUnsafeImport(f.Pkg.Pkg) {
-					f.linkName = parts[2]
-				}
-			case "//go:nobounds":
-				// Skip bounds checking in this function. Useful for some
-				// runtime functions.
-				// This is somewhat dangerous and thus only imported in packages
-				// that import unsafe.
-				if hasUnsafeImport(f.Pkg.Pkg) {
-					f.nobounds = true
-				}
-			}
-		}
-	}
-}
-
-func (f *Function) IsNoBounds() bool {
-	return f.nobounds
-}
-
-// Return true iff this function is externally visible.
-func (f *Function) IsExported() bool {
-	return f.exported || f.CName() != ""
-}
-
-// Return the inline directive of this function.
-func (f *Function) Inline() InlineType {
-	return f.inline
-}
-
-// Return the module name if not the default.
-func (f *Function) Module() string {
-	return f.module
-}
-
-// Return the link name for this function.
-func (f *Function) LinkName() string {
-	if f.linkName != "" {
-		return f.linkName
-	}
-	if f.Signature.Recv() != nil {
-		// Method on a defined type (which may be a pointer).
-		return f.RelString(nil)
-	} else {
-		// Bare function.
-		if name := f.CName(); name != "" {
-			// Name CGo functions directly.
-			return name
-		} else {
-			return f.RelString(nil)
-		}
-	}
-}
-
-// Return the name of the C function if this is a CGo wrapper. Otherwise, return
-// a zero-length string.
-func (f *Function) CName() string {
-	name := f.Name()
-	if strings.HasPrefix(name, "_Cfunc_") {
-		// emitted by `go tool cgo`
-		return name[len("_Cfunc_"):]
-	}
-	if strings.HasPrefix(name, "C.") {
-		// created by ../loader/cgo.go
-		return name[2:]
-	}
-	return ""
-}
-
-// Get all methods of a type.
-func getAllMethods(prog *ssa.Program, typ types.Type) []*types.Selection {
-	ms := prog.MethodSets.MethodSet(typ)
-	methods := make([]*types.Selection, ms.Len())
-	for i := 0; i < ms.Len(); i++ {
-		methods[i] = ms.At(i)
-	}
-	return methods
-}

ir/passes.go

@@ -1,149 +0,0 @@
-package ir
-
-import (
-	"errors"
-	"go/types"
-
-	"golang.org/x/tools/go/ssa"
-)
-
-// This file implements several optimization passes (analysis + transform) to
-// optimize code in SSA form before it is compiled to LLVM IR. It is based on
-// the IR defined in ir.go.
-
-// Make a readable version of a method signature (including the function name,
-// excluding the receiver name). This string is used internally to match
-// interfaces and to call the correct method on an interface. Examples:
-//
-//     String() string
-//     Read([]byte) (int, error)
-func MethodSignature(method *types.Func) string {
-	return method.Name() + signature(method.Type().(*types.Signature))
-}
-
-// Make a readable version of a function (pointer) signature.
-// Examples:
-//
-//     () string
-//     (string, int) (int, error)
-func signature(sig *types.Signature) string {
-	s := ""
-	if sig.Params().Len() == 0 {
-		s += "()"
-	} else {
-		s += "("
-		for i := 0; i < sig.Params().Len(); i++ {
-			if i > 0 {
-				s += ", "
-			}
-			s += sig.Params().At(i).Type().String()
-		}
-		s += ")"
-	}
-	if sig.Results().Len() == 0 {
-		// keep as-is
-	} else if sig.Results().Len() == 1 {
-		s += " " + sig.Results().At(0).Type().String()
-	} else {
-		s += " ("
-		for i := 0; i < sig.Results().Len(); i++ {
-			if i > 0 {
-				s += ", "
-			}
-			s += sig.Results().At(i).Type().String()
-		}
-		s += ")"
-	}
-	return s
-}
-
-// Simple pass that removes dead code. This pass makes later analysis passes
-// more useful.
-func (p *Program) SimpleDCE() error {
-	// Unmark all functions.
-	for _, f := range p.Functions {
-		f.flag = false
-	}
-
-	// Initial set of live functions. Include main.main, *.init and runtime.*
-	// functions.
-	main, ok := p.mainPkg.Members["main"].(*ssa.Function)
-	if !ok {
-		if p.mainPkg.Members["main"] == nil {
-			return errors.New("function main is undeclared in the main package")
-		} else {
-			return errors.New("cannot declare main - must be func")
-		}
-	}
-	runtimePkg := p.Program.ImportedPackage("runtime")
-	mathPkg := p.Program.ImportedPackage("math")
-	taskPkg := p.Program.ImportedPackage("internal/task")
-	p.GetFunction(main).flag = true
-	worklist := []*ssa.Function{main}
-	for _, f := range p.Functions {
-		if f.exported || f.Synthetic == "package initializer" || f.Pkg == runtimePkg || f.Pkg == taskPkg || (f.Pkg == mathPkg && f.Pkg != nil) {
-			if f.flag {
-				continue
-			}
-			f.flag = true
-			worklist = append(worklist, f.Function)
-		}
-	}
-
-	// Mark all called functions recursively.
-	for len(worklist) != 0 {
-		f := worklist[len(worklist)-1]
-		worklist = worklist[:len(worklist)-1]
-		for _, block := range f.Blocks {
-			for _, instr := range block.Instrs {
-				if instr, ok := instr.(*ssa.MakeInterface); ok {
-					for _, sel := range getAllMethods(p.Program, instr.X.Type()) {
-						fn := p.Program.MethodValue(sel)
-						callee := p.GetFunction(fn)
-						if callee == nil {
-							// TODO: why is this necessary?
-							p.addFunction(fn)
-							callee = p.GetFunction(fn)
-						}
-						if !callee.flag {
-							callee.flag = true
-							worklist = append(worklist, callee.Function)
-						}
-					}
-				}
-				for _, operand := range instr.Operands(nil) {
-					if operand == nil || *operand == nil {
-						continue
-					}
-					switch operand := (*operand).(type) {
-					case *ssa.Function:
-						f := p.GetFunction(operand)
-						if f == nil {
-							// FIXME HACK: this function should have been
-							// discovered already. It is not for bound methods.
-							p.addFunction(operand)
-							f = p.GetFunction(operand)
-						}
-						if !f.flag {
-							f.flag = true
-							worklist = append(worklist, operand)
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// Remove unmarked functions.
-	livefunctions := []*Function{}
-	for _, f := range p.Functions {
-		if f.flag {
-			livefunctions = append(livefunctions, f)
-		} else {
-			delete(p.functionMap, f.Function)
-		}
-	}
-	p.Functions = livefunctions
-
-	return nil
-}

loader/errors.go

@@ -1,5 +1,10 @@
 package loader
 
+import (
+	"go/token"
+	"strings"
+)
+
 // Errors contains a list of parser errors or a list of typechecker errors for
 // the given package.
 type Errors struct {
@@ -10,3 +15,25 @@ type Errors struct {
 func (e Errors) Error() string {
 	return "could not compile: " + e.Errs[0].Error()
 }
+
+// ImportCycleErrors is returned when encountering an import cycle. The list of
+// packages is a list from the root package to the leaf package that imports one
+// of the packages in the list.
+type ImportCycleError struct {
+	Packages        []string
+	ImportPositions []token.Position
+}
+
+func (e *ImportCycleError) Error() string {
+	var msg strings.Builder
+	msg.WriteString("import cycle:\n\t")
+	msg.WriteString(strings.Join(e.Packages, "\n\t"))
+	msg.WriteString("\n at ")
+	for i, pos := range e.ImportPositions {
+		if i > 0 {
+			msg.WriteString(", ")
+		}
+		msg.WriteString(pos.String())
+	}
+	return msg.String()
+}

loader/goroot.go

@@ -1,240 +0,0 @@
-package loader
-
-// This file constructs a new temporary GOROOT directory by merging both the
-// standard Go GOROOT and the GOROOT from TinyGo using symlinks.
-
-import (
-	"crypto/sha512"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"runtime"
-	"strconv"
-
-	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-// GetCachedGoroot creates a new GOROOT by merging both the standard GOROOT and
-// the GOROOT from TinyGo using lots of symbolic links.
-func GetCachedGoroot(config *compileopts.Config) (string, error) {
-	goroot := goenv.Get("GOROOT")
-	if goroot == "" {
-		return "", errors.New("could not determine GOROOT")
-	}
-	tinygoroot := goenv.Get("TINYGOROOT")
-	if tinygoroot == "" {
-		return "", errors.New("could not determine TINYGOROOT")
-	}
-
-	// Determine the location of the cached GOROOT.
-	version, err := goenv.GorootVersionString(goroot)
-	if err != nil {
-		return "", err
-	}
-	// This hash is really a cache key, that contains (hopefully) enough
-	// information to make collisions unlikely during development.
-	// By including the Go version and TinyGo version, cache collisions should
-	// not happen outside of development.
-	hash := sha512.New512_256()
-	fmt.Fprintln(hash, goroot)
-	fmt.Fprintln(hash, version)
-	fmt.Fprintln(hash, goenv.Version)
-	fmt.Fprintln(hash, tinygoroot)
-	gorootsHash := hash.Sum(nil)
-	gorootsHashHex := hex.EncodeToString(gorootsHash[:])
-	cachedgoroot := filepath.Join(goenv.Get("GOCACHE"), "goroot-"+version+"-"+gorootsHashHex)
-	if needsSyscallPackage(config.BuildTags()) {
-		cachedgoroot += "-syscall"
-	}
-
-	if _, err := os.Stat(cachedgoroot); err == nil {
-		return cachedgoroot, nil
-	}
-	tmpgoroot := cachedgoroot + ".tmp" + strconv.Itoa(rand.Int())
-	err = os.MkdirAll(tmpgoroot, 0777)
-	if err != nil {
-		return "", err
-	}
-
-	// Remove the temporary directory if it wasn't moved to the right place
-	// (for example, when there was an error).
-	defer os.RemoveAll(tmpgoroot)
-
-	for _, name := range []string{"bin", "lib", "pkg"} {
-		err = symlink(filepath.Join(goroot, name), filepath.Join(tmpgoroot, name))
-		if err != nil {
-			return "", err
-		}
-	}
-	err = mergeDirectory(goroot, tinygoroot, tmpgoroot, "", pathsToOverride(needsSyscallPackage(config.BuildTags())))
-	if err != nil {
-		return "", err
-	}
-	err = os.Rename(tmpgoroot, cachedgoroot)
-	if err != nil {
-		if os.IsExist(err) {
-			// Another invocation of TinyGo also seems to have created a GOROOT.
-			// Use that one instead. Our new GOROOT will be automatically
-			// deleted by the defer above.
-			return cachedgoroot, nil
-		}
-		return "", err
-	}
-	return cachedgoroot, nil
-}
-
-// mergeDirectory merges two roots recursively. The tmpgoroot is the directory
-// that will be created by this call by either symlinking the directory from
-// goroot or tinygoroot, or by creating the directory and merging the contents.
-func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides map[string]bool) error {
-	if mergeSubdirs, ok := overrides[importPath+"/"]; ok {
-		if !mergeSubdirs {
-			// This directory and all subdirectories should come from the TinyGo
-			// root, so simply make a symlink.
-			newname := filepath.Join(tmpgoroot, "src", importPath)
-			oldname := filepath.Join(tinygoroot, "src", importPath)
-			return symlink(oldname, newname)
-		}
-
-		// Merge subdirectories. Start by making the directory to merge.
-		err := os.Mkdir(filepath.Join(tmpgoroot, "src", importPath), 0777)
-		if err != nil {
-			return err
-		}
-
-		// Symlink all files from TinyGo, and symlink directories from TinyGo
-		// that need to be overridden.
-		tinygoEntries, err := ioutil.ReadDir(filepath.Join(tinygoroot, "src", importPath))
-		if err != nil {
-			return err
-		}
-		for _, e := range tinygoEntries {
-			if e.IsDir() {
-				// A directory, so merge this thing.
-				err := mergeDirectory(goroot, tinygoroot, tmpgoroot, path.Join(importPath, e.Name()), overrides)
-				if err != nil {
-					return err
-				}
-			} else {
-				// A file, so symlink this.
-				newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
-				oldname := filepath.Join(tinygoroot, "src", importPath, e.Name())
-				err := symlink(oldname, newname)
-				if err != nil {
-					return err
-				}
-			}
-		}
-
-		// Symlink all directories from $GOROOT that are not part of the TinyGo
-		// overrides.
-		gorootEntries, err := ioutil.ReadDir(filepath.Join(goroot, "src", importPath))
-		if err != nil {
-			return err
-		}
-		for _, e := range gorootEntries {
-			if !e.IsDir() {
-				// Don't merge in files from Go. Otherwise we'd end up with a
-				// weird syscall package with files from both roots.
-				continue
-			}
-			if _, ok := overrides[path.Join(importPath, e.Name())+"/"]; ok {
-				// Already included above, so don't bother trying to create this
-				// symlink.
-				continue
-			}
-			newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
-			oldname := filepath.Join(goroot, "src", importPath, e.Name())
-			err := symlink(oldname, newname)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// needsSyscallPackage returns whether the syscall package should be overriden
-// 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" {
-			return true
-		}
-	}
-	return false
-}
-
-// The boolean indicates whether to merge the subdirs. True means merge, false
-// means use the TinyGo version.
-func pathsToOverride(needsSyscallPackage bool) map[string]bool {
-	paths := map[string]bool{
-		"/":                     true,
-		"device/":               false,
-		"examples/":             false,
-		"internal/":             true,
-		"internal/bytealg/":     false,
-		"internal/reflectlite/": false,
-		"internal/task/":        false,
-		"machine/":              false,
-		"os/":                   true,
-		"reflect/":              false,
-		"runtime/":              false,
-		"sync/":                 true,
-		"testing/":              false,
-	}
-	if needsSyscallPackage {
-		paths["syscall/"] = true // include syscall/js
-	}
-	return paths
-}
-
-// symlink creates a symlink or something similar. On Unix-like systems, it
-// always creates a symlink. On Windows, it tries to create a symlink and if
-// that fails, creates a hardlink or directory junction instead.
-//
-// Note that while Windows 10 does support symlinks and allows them to be
-// created using os.Symlink, it requires developer mode to be enabled.
-// Therefore provide a fallback for when symlinking is not possible.
-// Unfortunately this fallback only works when TinyGo is installed on the same
-// filesystem as the TinyGo cache and the Go installation (which is usually the
-// C drive).
-func symlink(oldname, newname string) error {
-	symlinkErr := os.Symlink(oldname, newname)
-	if runtime.GOOS == "windows" && symlinkErr != nil {
-		// Fallback for when developer mode is disabled.
-		// Note that we return the symlink error even if something else fails
-		// later on. This is because symlinks are the easiest to support
-		// (they're also used on Linux and MacOS) and enabling them is easy:
-		// just enable developer mode.
-		st, err := os.Stat(oldname)
-		if err != nil {
-			return symlinkErr
-		}
-		if st.IsDir() {
-			// Make a directory junction. There may be a way to do this
-			// programmatically, but it involves a lot of magic. Use the mklink
-			// command built into cmd instead (mklink is a builtin, not an
-			// external command).
-			err := exec.Command("cmd", "/k", "mklink", "/J", newname, oldname).Run()
-			if err != nil {
-				return symlinkErr
-			}
-		} else {
-			// Make a hard link.
-			err := os.Link(oldname, newname)
-			if err != nil {
-				return symlinkErr
-			}
-		}
-		return nil // success
-	}
-	return symlinkErr
-}

loader/loader.go

@@ -3,7 +3,6 @@ package loader
 import (
 	"bytes"
 	"errors"
-	"fmt"
 	"go/ast"
 	"go/build"
 	"go/parser"
@@ -13,191 +12,114 @@ import (
 	"os"
 	"path/filepath"
 	"sort"
-	"strconv"
 	"strings"
 	"text/template"
 
 	"github.com/tinygo-org/tinygo/cgo"
-	"github.com/tinygo-org/tinygo/goenv"
-	"golang.org/x/tools/go/packages"
 )
 
 // Program holds all packages and some metadata about the program as a whole.
 type Program struct {
+	mainPkg      string
 	Build        *build.Context
-	Tests        bool
+	OverlayBuild *build.Context
+	OverlayPath  func(path string) string
 	Packages     map[string]*Package
-	MainPkg      *Package
 	sorted       []*Package
 	fset         *token.FileSet
 	TypeChecker  types.Config
 	Dir          string // current working directory (for error reporting)
 	TINYGOROOT   string // root of the TinyGo installation or root of the source code
 	CFlags       []string
-	LDFlags      []string
 	ClangHeaders string
 }
 
 // Package holds a loaded package, its imports, and its parsed files.
 type Package struct {
 	*Program
-	*packages.Package
-	Files []*ast.File
-	Pkg   *types.Package
+	*build.Package
+	Imports   map[string]*Package
+	Importing bool
+	Files     []*ast.File
+	Pkg       *types.Package
 	types.Info
 }
 
-// Load loads the given package with all dependencies (including the runtime
-// package). Call .Parse() afterwards to parse all Go files (including CGo
-// processing, if necessary).
-func (p *Program) Load(importPath string) error {
+// Import loads the given package relative to srcDir (for the vendor directory).
+// It only loads the current package without recursion.
+func (p *Program) Import(path, srcDir string, pos token.Position) (*Package, error) {
 	if p.Packages == nil {
 		p.Packages = make(map[string]*Package)
 	}
 
-	err := p.loadPackage(importPath)
+	// Load this package.
+	ctx := p.Build
+	if newPath := p.OverlayPath(path); newPath != "" {
+		ctx = p.OverlayBuild
+		path = newPath
+	}
+	buildPkg, err := ctx.Import(path, srcDir, build.ImportComment)
 	if err != nil {
-		return err
+		return nil, scanner.Error{
+			Pos: pos,
+			Msg: err.Error(), // TODO: define a new error type that will wrap the inner error
+		}
 	}
-	p.MainPkg = p.sorted[len(p.sorted)-1]
-	if _, ok := p.Packages["runtime"]; !ok {
-		// The runtime package wasn't loaded. Although `go list -deps` seems to
-		// return the full dependency list, there is no way to get those
-		// packages from the go/packages package. Therefore load the runtime
-		// manually and add it to the list of to-be-compiled packages
-		// (duplicates are already filtered).
-		return p.loadPackage("runtime")
+	if existingPkg, ok := p.Packages[buildPkg.ImportPath]; ok {
+		// Already imported, or at least started the import.
+		return existingPkg, nil
 	}
-	return nil
+	p.sorted = nil // invalidate the sorted order of packages
+	pkg := p.newPackage(buildPkg)
+	p.Packages[buildPkg.ImportPath] = pkg
+
+	if p.mainPkg == "" {
+		p.mainPkg = buildPkg.ImportPath
+	}
+
+	return pkg, nil
 }
 
-func (p *Program) loadPackage(importPath string) error {
-	cgoEnabled := "0"
-	if p.Build.CgoEnabled {
-		cgoEnabled = "1"
+// ImportFile loads and parses the import statements in the given path and
+// creates a pseudo-package out of it.
+func (p *Program) ImportFile(path string) (*Package, error) {
+	if p.Packages == nil {
+		p.Packages = make(map[string]*Package)
 	}
-	pkgs, err := packages.Load(&packages.Config{
-		Mode:       packages.NeedName | packages.NeedFiles | packages.NeedImports | packages.NeedDeps,
-		Env:        append(os.Environ(), "GOROOT="+p.Build.GOROOT, "GOOS="+p.Build.GOOS, "GOARCH="+p.Build.GOARCH, "CGO_ENABLED="+cgoEnabled),
-		BuildFlags: []string{"-tags", strings.Join(p.Build.BuildTags, " ")},
-		Tests:      p.Tests,
-	}, importPath)
+	if _, ok := p.Packages[path]; ok {
+		// unlikely
+		return nil, errors.New("loader: cannot import file that is already imported as package: " + path)
+	}
+
+	file, err := p.parseFile(path, parser.ImportsOnly)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	var pkg *packages.Package
-	if p.Tests {
-		// We need the second package. Quoting from the docs:
-		// > For example, when using the go command, loading "fmt" with Tests=true
-		// > returns four packages, with IDs "fmt" (the standard package),
-		// > "fmt [fmt.test]" (the package as compiled for the test),
-		// > "fmt_test" (the test functions from source files in package fmt_test),
-		// > and "fmt.test" (the test binary).
-		pkg = pkgs[1]
-	} else {
-		if len(pkgs) != 1 {
-			return fmt.Errorf("expected exactly one package while importing %s, got %d", importPath, len(pkgs))
-		}
-		pkg = pkgs[0]
+	buildPkg := &build.Package{
+		Dir:        filepath.Dir(path),
+		ImportPath: path,
+		GoFiles:    []string{filepath.Base(path)},
 	}
-	var importError *Errors
-	var addPackages func(pkg *packages.Package)
-	addPackages = func(pkg *packages.Package) {
-		if _, ok := p.Packages[pkg.PkgPath]; ok {
-			return
-		}
-		pkg2 := p.newPackage(pkg)
-		p.Packages[pkg.PkgPath] = pkg2
-		if len(pkg.Errors) != 0 {
-			if importError != nil {
-				// There was another error reported already. Do not report
-				// errors from multiple packages at once.
-				return
-			}
-			importError = &Errors{
-				Pkg: pkg2,
-			}
-			for _, err := range pkg.Errors {
-				pos := token.Position{}
-				fields := strings.Split(err.Pos, ":")
-				if len(fields) >= 2 {
-					// There is some file/line/column information.
-					if n, err := strconv.Atoi(fields[len(fields)-2]); err == nil {
-						// Format: filename.go:line:colum
-						pos.Filename = strings.Join(fields[:len(fields)-2], ":")
-						pos.Line = n
-						pos.Column, _ = strconv.Atoi(fields[len(fields)-1])
-					} else {
-						// Format: filename.go:line
-						pos.Filename = strings.Join(fields[:len(fields)-1], ":")
-						pos.Line, _ = strconv.Atoi(fields[len(fields)-1])
-					}
-					pos.Filename = p.getOriginalPath(pos.Filename)
-				}
-				importError.Errs = append(importError.Errs, scanner.Error{
-					Pos: pos,
-					Msg: err.Msg,
-				})
-			}
-			return
-		}
+	for _, importSpec := range file.Imports {
+		buildPkg.Imports = append(buildPkg.Imports, importSpec.Path.Value[1:len(importSpec.Path.Value)-1])
+	}
+	p.sorted = nil // invalidate the sorted order of packages
+	pkg := p.newPackage(buildPkg)
+	p.Packages[buildPkg.ImportPath] = pkg
 
-		// Get the list of imports (sorted alphabetically).
-		names := make([]string, 0, len(pkg.Imports))
-		for name := range pkg.Imports {
-			names = append(names, name)
-		}
-		sort.Strings(names)
-
-		// Add all the imports.
-		for _, name := range names {
-			addPackages(pkg.Imports[name])
-		}
-
-		p.sorted = append(p.sorted, pkg2)
+	if p.mainPkg == "" {
+		p.mainPkg = buildPkg.ImportPath
 	}
-	addPackages(pkg)
-	if importError != nil {
-		return *importError
-	}
-	return nil
-}
 
-// getOriginalPath looks whether this path is in the generated GOROOT and if so,
-// replaces the path with the original path (in GOROOT or TINYGOROOT). Otherwise
-// the input path is returned.
-func (p *Program) getOriginalPath(path string) string {
-	originalPath := path
-	if strings.HasPrefix(path, p.Build.GOROOT+string(filepath.Separator)) {
-		// If this file is part of the synthetic GOROOT, try to infer the
-		// original path.
-		relpath := path[len(filepath.Join(p.Build.GOROOT, "src"))+1:]
-		realgorootPath := filepath.Join(goenv.Get("GOROOT"), "src", relpath)
-		if _, err := os.Stat(realgorootPath); err == nil {
-			originalPath = realgorootPath
-		}
-		maybeInTinyGoRoot := false
-		for prefix := range pathsToOverride(needsSyscallPackage(p.Build.BuildTags)) {
-			if !strings.HasPrefix(relpath, prefix) {
-				continue
-			}
-			maybeInTinyGoRoot = true
-		}
-		if maybeInTinyGoRoot {
-			tinygoPath := filepath.Join(p.TINYGOROOT, "src", relpath)
-			if _, err := os.Stat(tinygoPath); err == nil {
-				originalPath = tinygoPath
-			}
-		}
-	}
-	return originalPath
+	return pkg, nil
 }
 
 // newPackage instantiates a new *Package object with initialized members.
-func (p *Program) newPackage(pkg *packages.Package) *Package {
+func (p *Program) newPackage(pkg *build.Package) *Package {
 	return &Package{
 		Program: p,
 		Package: pkg,
+		Imports: make(map[string]*Package, len(pkg.Imports)),
 		Info: types.Info{
 			Types:      make(map[ast.Expr]types.TypeAndValue),
 			Defs:       make(map[*ast.Ident]types.Object),
@@ -212,25 +134,87 @@ func (p *Program) newPackage(pkg *packages.Package) *Package {
 // Sorted returns a list of all packages, sorted in a way that no packages come
 // before the packages they depend upon.
 func (p *Program) Sorted() []*Package {
+	if p.sorted == nil {
+		p.sort()
+	}
 	return p.sorted
 }
 
-// Parse parses all packages and typechecks them.
+func (p *Program) sort() {
+	p.sorted = nil
+	packageList := make([]*Package, 0, len(p.Packages))
+	packageSet := make(map[string]struct{}, len(p.Packages))
+	worklist := make([]string, 0, len(p.Packages))
+	for path := range p.Packages {
+		worklist = append(worklist, path)
+	}
+	sort.Strings(worklist)
+	for len(worklist) != 0 {
+		pkgPath := worklist[0]
+		pkg := p.Packages[pkgPath]
+
+		if _, ok := packageSet[pkgPath]; ok {
+			// Package already in the final package list.
+			worklist = worklist[1:]
+			continue
+		}
+
+		unsatisfiedImports := make([]string, 0)
+		for _, pkg := range pkg.Imports {
+			if _, ok := packageSet[pkg.ImportPath]; ok {
+				continue
+			}
+			unsatisfiedImports = append(unsatisfiedImports, pkg.ImportPath)
+		}
+		sort.Strings(unsatisfiedImports)
+		if len(unsatisfiedImports) == 0 {
+			// All dependencies of this package are satisfied, so add this
+			// package to the list.
+			packageList = append(packageList, pkg)
+			packageSet[pkgPath] = struct{}{}
+			worklist = worklist[1:]
+		} else {
+			// Prepend all dependencies to the worklist and reconsider this
+			// package (by not removing it from the worklist). At that point, it
+			// must be possible to add it to packageList.
+			worklist = append(unsatisfiedImports, worklist...)
+		}
+	}
+
+	p.sorted = packageList
+}
+
+// Parse recursively imports all packages, parses them, and typechecks them.
 //
 // The returned error may be an Errors error, which contains a list of errors.
 //
 // Idempotent.
-func (p *Program) Parse() error {
+func (p *Program) Parse(compileTestBinary bool) error {
+	includeTests := compileTestBinary
+
+	// Load all imports
+	for _, pkg := range p.Sorted() {
+		err := pkg.importRecursively(includeTests)
+		if err != nil {
+			if err, ok := err.(*ImportCycleError); ok {
+				if pkg.ImportPath != err.Packages[0] {
+					err.Packages = append([]string{pkg.ImportPath}, err.Packages...)
+				}
+			}
+			return err
+		}
+	}
+
 	// Parse all packages.
 	for _, pkg := range p.Sorted() {
-		err := pkg.Parse()
+		err := pkg.Parse(includeTests)
 		if err != nil {
 			return err
 		}
 	}
 
-	if p.Tests {
-		err := p.swapTestMain()
+	if compileTestBinary {
+		err := p.SwapTestMain()
 		if err != nil {
 			return err
 		}
@@ -247,7 +231,7 @@ func (p *Program) Parse() error {
 	return nil
 }
 
-func (p *Program) swapTestMain() error {
+func (p *Program) SwapTestMain() error {
 	var tests []string
 
 	isTestFunc := func(f *ast.FuncDecl) bool {
@@ -257,7 +241,8 @@ func (p *Program) swapTestMain() error {
 		}
 		return false
 	}
-	for _, f := range p.MainPkg.Files {
+	mainPkg := p.Packages[p.mainPkg]
+	for _, f := range mainPkg.Files {
 		for i, d := range f.Decls {
 			switch v := d.(type) {
 			case *ast.FuncDecl:
@@ -308,7 +293,7 @@ func main () {
 	if err != nil {
 		return err
 	}
-	path := filepath.Join(p.MainPkg.Dir, "$testmain.go")
+	path := filepath.Join(p.mainPkg, "$testmain.go")
 
 	if p.fset == nil {
 		p.fset = token.NewFileSet()
@@ -318,7 +303,7 @@ func main () {
 	if err != nil {
 		return err
 	}
-	p.MainPkg.Files = append(p.MainPkg.Files, newMain)
+	mainPkg.Files = append(mainPkg.Files, newMain)
 
 	return nil
 }
@@ -334,27 +319,34 @@ func (p *Program) parseFile(path string, mode parser.Mode) (*ast.File, error) {
 		return nil, err
 	}
 	defer rd.Close()
-	return parser.ParseFile(p.fset, p.getOriginalPath(path), rd, mode)
+	relpath := path
+	if filepath.IsAbs(path) {
+		rp, err := filepath.Rel(p.Dir, path)
+		if err == nil {
+			relpath = rp
+		}
+	}
+	return parser.ParseFile(p.fset, relpath, rd, mode)
 }
 
 // Parse parses and typechecks this package.
 //
 // Idempotent.
-func (p *Package) Parse() error {
+func (p *Package) Parse(includeTests bool) error {
 	if len(p.Files) != 0 {
 		return nil
 	}
 
 	// Load the AST.
 	// TODO: do this in parallel.
-	if p.PkgPath == "unsafe" {
+	if p.ImportPath == "unsafe" {
 		// Special case for the unsafe package. Don't even bother loading
 		// the files.
 		p.Pkg = types.Unsafe
 		return nil
 	}
 
-	files, err := p.parseFiles()
+	files, err := p.parseFiles(includeTests)
 	if err != nil {
 		return err
 	}
@@ -381,7 +373,7 @@ func (p *Package) Check() error {
 	// Do typechecking of the package.
 	checker.Importer = p
 
-	typesPkg, err := checker.Check(p.PkgPath, p.fset, p.Files, &p.Info)
+	typesPkg, err := checker.Check(p.ImportPath, p.fset, p.Files, &p.Info)
 	if err != nil {
 		if err, ok := err.(Errors); ok {
 			return err
@@ -393,14 +385,22 @@ func (p *Package) Check() error {
 }
 
 // parseFiles parses the loaded list of files and returns this list.
-func (p *Package) parseFiles() ([]*ast.File, error) {
+func (p *Package) parseFiles(includeTests bool) ([]*ast.File, error) {
 	// TODO: do this concurrently.
 	var files []*ast.File
 	var fileErrs []error
 
-	var cgoFiles []*ast.File
-	for _, file := range p.GoFiles {
-		f, err := p.parseFile(file, parser.ParseComments)
+	var gofiles []string
+	if includeTests {
+		gofiles = make([]string, 0, len(p.GoFiles)+len(p.TestGoFiles))
+		gofiles = append(gofiles, p.GoFiles...)
+		gofiles = append(gofiles, p.TestGoFiles...)
+	} else {
+		gofiles = p.GoFiles
+	}
+
+	for _, file := range gofiles {
+		f, err := p.parseFile(filepath.Join(p.Package.Dir, file), parser.ParseComments)
 		if err != nil {
 			fileErrs = append(fileErrs, err)
 			continue
@@ -409,24 +409,27 @@ func (p *Package) parseFiles() ([]*ast.File, error) {
 			fileErrs = append(fileErrs, err)
 			continue
 		}
-		for _, importSpec := range f.Imports {
-			if importSpec.Path.Value == `"C"` {
-				cgoFiles = append(cgoFiles, f)
-			}
-		}
 		files = append(files, f)
 	}
-	if len(cgoFiles) != 0 {
-		cflags := append(p.CFlags, "-I"+filepath.Dir(p.GoFiles[0]))
+	for _, file := range p.CgoFiles {
+		path := filepath.Join(p.Package.Dir, file)
+		f, err := p.parseFile(path, parser.ParseComments)
+		if err != nil {
+			fileErrs = append(fileErrs, err)
+			continue
+		}
+		files = append(files, f)
+	}
+	if len(p.CgoFiles) != 0 {
+		cflags := append(p.CFlags, "-I"+p.Package.Dir)
 		if p.ClangHeaders != "" {
 			cflags = append(cflags, "-Xclang", "-internal-isystem", "-Xclang", p.ClangHeaders)
 		}
-		generated, ldflags, errs := cgo.Process(files, p.Program.Dir, p.fset, cflags)
+		generated, errs := cgo.Process(files, p.Program.Dir, p.fset, cflags)
 		if errs != nil {
 			fileErrs = append(fileErrs, errs...)
 		}
 		files = append(files, generated)
-		p.LDFlags = append(p.LDFlags, ldflags...)
 	}
 	if len(fileErrs) != 0 {
 		return nil, Errors{p, fileErrs}
@@ -442,8 +445,58 @@ func (p *Package) Import(to string) (*types.Package, error) {
 		return types.Unsafe, nil
 	}
 	if _, ok := p.Imports[to]; ok {
-		return p.Packages[p.Imports[to].PkgPath].Pkg, nil
+		return p.Imports[to].Pkg, nil
 	} else {
 		return nil, errors.New("package not imported: " + to)
 	}
 }
+
+// importRecursively calls Program.Import() on all imported packages, and calls
+// importRecursively() on the imported packages as well.
+//
+// Idempotent.
+func (p *Package) importRecursively(includeTests bool) error {
+	p.Importing = true
+
+	imports := p.Package.Imports
+	if includeTests {
+		imports = append(imports, p.Package.TestImports...)
+	}
+
+	for _, to := range imports {
+		if to == "C" {
+			// Do CGo processing in a later stage.
+			continue
+		}
+		if _, ok := p.Imports[to]; ok {
+			continue
+		}
+		// Find error location.
+		var pos token.Position
+		if len(p.Package.ImportPos[to]) > 0 {
+			pos = p.Package.ImportPos[to][0]
+		} else {
+			pos = token.Position{Filename: p.Package.ImportPath}
+		}
+		importedPkg, err := p.Program.Import(to, p.Package.Dir, pos)
+		if err != nil {
+			if err, ok := err.(*ImportCycleError); ok {
+				err.Packages = append([]string{p.ImportPath}, err.Packages...)
+			}
+			return err
+		}
+		if importedPkg.Importing {
+			return &ImportCycleError{[]string{p.ImportPath, importedPkg.ImportPath}, p.ImportPos[to]}
+		}
+		err = importedPkg.importRecursively(false)
+		if err != nil {
+			if err, ok := err.(*ImportCycleError); ok {
+				err.Packages = append([]string{p.ImportPath}, err.Packages...)
+			}
+			return err
+		}
+		p.Imports[to] = importedPkg
+	}
+	p.Importing = false
+	return nil
+}

main.go

@@ -124,7 +124,6 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 
 // Test runs the tests in the given package.
 func Test(pkgName string, options *compileopts.Options) error {
-	options.TestConfig.CompileTestBinary = true
 	config, err := builder.NewConfig(options)
 	if err != nil {
 		return err
@@ -136,6 +135,7 @@ func Test(pkgName string, options *compileopts.Options) error {
 	// For details: https://github.com/golang/go/issues/21360
 	config.Target.BuildTags = append(config.Target.BuildTags, "test")
 
+	options.TestConfig.CompileTestBinary = true
 	return builder.Build(pkgName, ".elf", config, func(tmppath string) error {
 		cmd := exec.Command(tmppath)
 		cmd.Stdout = os.Stdout
@@ -310,12 +310,10 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 		switch gdbInterface {
 		case "msd", "command", "":
 			if len(config.Target.Emulator) != 0 {
+				// Assume QEMU as an emulator.
 				if config.Target.Emulator[0] == "mgba" {
 					gdbInterface = "mgba"
-				} else if config.Target.Emulator[0] == "simavr" {
-					gdbInterface = "simavr"
 				} else {
-					// Assume QEMU as an emulator.
 					gdbInterface = "qemu"
 				}
 			} else if openocdInterface != "" && config.Target.OpenOCDTarget != "" {
@@ -381,14 +379,6 @@ func FlashGDB(pkgName string, ocdOutput bool, options *compileopts.Options) erro
 			daemon = exec.Command(config.Target.Emulator[0], args...)
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
-		case "simavr":
-			gdbCommands = append(gdbCommands, "target remote :1234")
-
-			// Run in an emulator.
-			args := append(config.Target.Emulator[1:], "-g", tmppath)
-			daemon = exec.Command(config.Target.Emulator[0], args...)
-			daemon.Stdout = os.Stdout
-			daemon.Stderr = os.Stderr
 		case "msd":
 			return errors.New("gdb is not supported for drag-and-drop programmable devices")
 		default:
@@ -489,13 +479,6 @@ func touchSerialPortAt1200bps(port string) (err error) {
 		// Open port
 		p, e := serial.Open(port, &serial.Mode{BaudRate: 1200})
 		if e != nil {
-			if runtime.GOOS == `windows` {
-				se, ok := e.(*serial.PortError)
-				if ok && se.Code() == serial.InvalidSerialPort {
-					// InvalidSerialPort error occurs when transitioning to boot
-					return nil
-				}
-			}
 			time.Sleep(1 * time.Second)
 			err = e
 			continue
@@ -508,8 +491,6 @@ func touchSerialPortAt1200bps(port string) (err error) {
 	return fmt.Errorf("opening port: %s", err)
 }
 
-const maxMSDRetries = 10
-
 func flashUF2UsingMSD(volume, tmppath string) error {
 	// find standard UF2 info path
 	var infoPath string
@@ -526,12 +507,15 @@ func flashUF2UsingMSD(volume, tmppath string) error {
 		infoPath = path + "/INFO_UF2.TXT"
 	}
 
-	d, err := locateDevice(volume, infoPath)
+	d, err := filepath.Glob(infoPath)
 	if err != nil {
 		return err
 	}
+	if d == nil {
+		return errors.New("unable to locate UF2 device: " + volume)
+	}
 
-	return moveFile(tmppath, filepath.Dir(d)+"/flash.uf2")
+	return moveFile(tmppath, filepath.Dir(d[0])+"/flash.uf2")
 }
 
 func flashHexUsingMSD(volume, tmppath string) error {
@@ -550,31 +534,15 @@ func flashHexUsingMSD(volume, tmppath string) error {
 		destPath = path + "/"
 	}
 
-	d, err := locateDevice(volume, destPath)
+	d, err := filepath.Glob(destPath)
 	if err != nil {
 		return err
 	}
-
-	return moveFile(tmppath, d+"/flash.hex")
-}
-
-func locateDevice(volume, path string) (string, error) {
-	var d []string
-	var err error
-	for i := 0; i < maxMSDRetries; i++ {
-		d, err = filepath.Glob(path)
-		if err != nil {
-			return "", err
-		}
-		if d != nil {
-			break
-		}
-		time.Sleep(500 * time.Millisecond)
-	}
 	if d == nil {
-		return "", errors.New("unable to locate device: " + volume)
+		return errors.New("unable to locate device: " + volume)
 	}
-	return d[0], nil
+
+	return moveFile(tmppath, d[0]+"/flash.hex")
 }
 
 func windowsFindUSBDrive(volume string) (string, error) {
@@ -635,18 +603,29 @@ func getDefaultPort() (port string, err error) {
 	case "freebsd":
 		portPath = "/dev/cuaU*"
 	case "windows":
-		ports, err := serial.GetPortsList()
+		cmd := exec.Command("wmic",
+			"PATH", "Win32_SerialPort", "WHERE", "Caption LIKE 'USB Serial%'", "GET", "DeviceID")
+
+		var out bytes.Buffer
+		cmd.Stdout = &out
+		err := cmd.Run()
 		if err != nil {
 			return "", err
 		}
 
-		if len(ports) == 0 {
+		if out.String() == "No Instance(s) Available." {
 			return "", errors.New("no serial ports available")
-		} else if len(ports) > 1 {
-			return "", errors.New("multiple serial ports available - use -port flag")
 		}
 
-		return ports[0], nil
+		for _, line := range strings.Split(out.String(), "\n") {
+			words := strings.Fields(line)
+			if len(words) == 1 {
+				if strings.Contains(words[0], "COM") {
+					return words[0], nil
+				}
+			}
+		}
+		return "", errors.New("unable to locate a serial port")
 	default:
 		return "", errors.New("unable to search for a default USB device to be flashed on this OS")
 	}
@@ -662,39 +641,9 @@ func getDefaultPort() (port string, err error) {
 	return d[0], nil
 }
 
-// runGoList runs the `go list` command but using the configuration used for
-// TinyGo.
-func runGoList(config *compileopts.Config, flagJSON, flagDeps bool, pkgs []string) error {
-	goroot, err := loader.GetCachedGoroot(config)
-	if err != nil {
-		return err
-	}
-	args := []string{"list"}
-	if flagJSON {
-		args = append(args, "-json")
-	}
-	if flagDeps {
-		args = append(args, "-deps")
-	}
-	if len(config.BuildTags()) != 0 {
-		args = append(args, "-tags", strings.Join(config.BuildTags(), " "))
-	}
-	args = append(args, pkgs...)
-	cgoEnabled := "0"
-	if config.CgoEnabled() {
-		cgoEnabled = "1"
-	}
-	cmd := exec.Command("go", args...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Env = append(os.Environ(), "GOROOT="+goroot, "GOOS="+config.GOOS(), "GOARCH="+config.GOARCH(), "CGO_ENABLED="+cgoEnabled)
-	cmd.Run()
-	return nil
-}
-
 func usage() {
 	fmt.Fprintln(os.Stderr, "TinyGo is a Go compiler for small places.")
-	fmt.Fprintln(os.Stderr, "version:", goenv.Version)
+	fmt.Fprintln(os.Stderr, "version:", version)
 	fmt.Fprintf(os.Stderr, "usage: %s command [-printir] [-target=<target>] -o <output> <input>\n", os.Args[0])
 	fmt.Fprintln(os.Stderr, "\ncommands:")
 	fmt.Fprintln(os.Stderr, "  build: compile packages and dependencies")
@@ -703,27 +652,12 @@ func usage() {
 	fmt.Fprintln(os.Stderr, "  flash: compile and flash to the device")
 	fmt.Fprintln(os.Stderr, "  gdb:   run/flash and immediately enter GDB")
 	fmt.Fprintln(os.Stderr, "  env:   list environment variables used during build")
-	fmt.Fprintln(os.Stderr, "  list:  run go list using the TinyGo root")
 	fmt.Fprintln(os.Stderr, "  clean: empty cache directory ("+goenv.Get("GOCACHE")+")")
 	fmt.Fprintln(os.Stderr, "  help:  print this help text")
 	fmt.Fprintln(os.Stderr, "\nflags:")
 	flag.PrintDefaults()
 }
 
-// try to make the path relative to the current working directory. If any error
-// occurs, this error is ignored and the absolute path is returned instead.
-func tryToMakePathRelative(dir string) string {
-	wd, err := os.Getwd()
-	if err != nil {
-		return dir
-	}
-	relpath, err := filepath.Rel(wd, dir)
-	if err != nil {
-		return dir
-	}
-	return relpath
-}
-
 // printCompilerError prints compiler errors using the provided logger function
 // (similar to fmt.Println).
 //
@@ -731,24 +665,8 @@ func tryToMakePathRelative(dir string) string {
 // to limitations in the LLVM bindings.
 func printCompilerError(logln func(...interface{}), err error) {
 	switch err := err.(type) {
-	case types.Error:
-		printCompilerError(logln, scanner.Error{
-			Pos: err.Fset.Position(err.Pos),
-			Msg: err.Msg,
-		})
-	case scanner.Error:
-		if !strings.HasPrefix(err.Pos.Filename, filepath.Join(goenv.Get("GOROOT"), "src")) && !strings.HasPrefix(err.Pos.Filename, filepath.Join(goenv.Get("TINYGOROOT"), "src")) {
-			// This file is not from the standard library (either the GOROOT or
-			// the TINYGOROOT). Make the path relative, for easier reading.
-			// Ignore any errors in the process (falling back to the absolute
-			// path).
-			err.Pos.Filename = tryToMakePathRelative(err.Pos.Filename)
-		}
+	case types.Error, scanner.Error:
 		logln(err)
-	case scanner.ErrorList:
-		for _, scannerErr := range err {
-			printCompilerError(logln, *scannerErr)
-		}
 	case *interp.Error:
 		logln("#", err.ImportPath)
 		logln(err.Error())
@@ -765,13 +683,13 @@ func printCompilerError(logln func(...interface{}), err error) {
 			}
 		}
 	case loader.Errors:
-		logln("#", err.Pkg.PkgPath)
+		logln("#", err.Pkg.ImportPath)
 		for _, err := range err.Errs {
-			printCompilerError(logln, err)
+			logln(err)
 		}
 	case *builder.MultiError:
 		for _, err := range err.Errs {
-			printCompilerError(logln, err)
+			logln(err)
 		}
 	default:
 		logln("error:", err)
@@ -788,18 +706,11 @@ func handleCompilerError(err error) {
 }
 
 func main() {
-	if len(os.Args) < 2 {
-		fmt.Fprintln(os.Stderr, "No command-line arguments supplied.")
-		usage()
-		os.Exit(1)
-	}
-	command := os.Args[1]
-
 	outpath := flag.String("o", "", "output filename")
 	opt := flag.String("opt", "z", "optimization level: 0, 1, 2, s, z")
 	gc := flag.String("gc", "", "garbage collector to use (none, leaking, extalloc, conservative)")
 	panicStrategy := flag.String("panic", "print", "panic strategy (print, trap)")
-	scheduler := flag.String("scheduler", "", "which scheduler to use (none, coroutines, tasks)")
+	scheduler := flag.String("scheduler", "", "which scheduler to use (coroutines, tasks)")
 	printIR := flag.Bool("printir", false, "print LLVM IR")
 	dumpSSA := flag.Bool("dumpssa", false, "dump internal Go SSA")
 	verifyIR := flag.Bool("verifyir", false, "run extra verification steps on LLVM IR")
@@ -815,11 +726,12 @@ func main() {
 	wasmAbi := flag.String("wasm-abi", "js", "WebAssembly ABI conventions: js (no i64 params) or generic")
 	heapSize := flag.String("heap-size", "1M", "default heap size in bytes (only supported by WebAssembly)")
 
-	var flagJSON, flagDeps *bool
-	if command == "list" {
-		flagJSON = flag.Bool("json", false, "print data in JSON format")
-		flagDeps = flag.Bool("deps", false, "")
+	if len(os.Args) < 2 {
+		fmt.Fprintln(os.Stderr, "No command-line arguments supplied.")
+		usage()
+		os.Exit(1)
 	}
+	command := os.Args[1]
 
 	// Early command processing, before commands are interpreted by the Go flag
 	// library.
@@ -858,6 +770,12 @@ func main() {
 		options.LDFlags = strings.Split(*ldFlags, " ")
 	}
 
+	if *panicStrategy != "print" && *panicStrategy != "trap" {
+		fmt.Fprintln(os.Stderr, "Panic strategy must be either print or trap.")
+		usage()
+		os.Exit(1)
+	}
+
 	var err error
 	if options.HeapSize, err = parseSize(*heapSize); err != nil {
 		fmt.Fprintln(os.Stderr, "Could not read heap size:", *heapSize)
@@ -867,13 +785,6 @@ func main() {
 
 	os.Setenv("CC", "clang -target="+*target)
 
-	err = options.Verify()
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err.Error())
-		usage()
-		os.Exit(1)
-	}
-
 	switch command {
 	case "build":
 		if *outpath == "" {
@@ -883,7 +794,7 @@ func main() {
 		}
 		pkgName := "."
 		if flag.NArg() == 1 {
-			pkgName = filepath.ToSlash(flag.Arg(0))
+			pkgName = flag.Arg(0)
 		} else if flag.NArg() > 1 {
 			fmt.Fprintln(os.Stderr, "build only accepts a single positional argument: package name, but multiple were specified")
 			usage()
@@ -892,7 +803,6 @@ func main() {
 		if options.Target == "" && filepath.Ext(*outpath) == ".wasm" {
 			options.Target = "wasm"
 		}
-
 		err := Build(pkgName, *outpath, options)
 		handleCompilerError(err)
 	case "build-library":
@@ -929,9 +839,8 @@ func main() {
 			usage()
 			os.Exit(1)
 		}
-		pkgName := filepath.ToSlash(flag.Arg(0))
 		if command == "flash" {
-			err := Flash(pkgName, *port, options)
+			err := Flash(flag.Arg(0), *port, options)
 			handleCompilerError(err)
 		} else {
 			if !options.Debug {
@@ -939,7 +848,7 @@ func main() {
 				usage()
 				os.Exit(1)
 			}
-			err := FlashGDB(pkgName, *ocdOutput, options)
+			err := FlashGDB(flag.Arg(0), *ocdOutput, options)
 			handleCompilerError(err)
 		}
 	case "run":
@@ -948,13 +857,12 @@ func main() {
 			usage()
 			os.Exit(1)
 		}
-		pkgName := filepath.ToSlash(flag.Arg(0))
-		err := Run(pkgName, options)
+		err := Run(flag.Arg(0), options)
 		handleCompilerError(err)
 	case "test":
 		pkgName := "."
 		if flag.NArg() == 1 {
-			pkgName = filepath.ToSlash(flag.Arg(0))
+			pkgName = flag.Arg(0)
 		} else if flag.NArg() > 1 {
 			fmt.Fprintln(os.Stderr, "test only accepts a single positional argument: package name, but multiple were specified")
 			usage()
@@ -987,18 +895,6 @@ func main() {
 		fmt.Printf("build tags:        %s\n", strings.Join(config.BuildTags(), " "))
 		fmt.Printf("garbage collector: %s\n", config.GC())
 		fmt.Printf("scheduler:         %s\n", config.Scheduler())
-	case "list":
-		config, err := builder.NewConfig(options)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			usage()
-			os.Exit(1)
-		}
-		err = runGoList(config, *flagJSON, *flagDeps, flag.Args())
-		if err != nil {
-			fmt.Fprintln(os.Stderr, "failed to run `go list`:", err)
-			os.Exit(1)
-		}
 	case "clean":
 		// remove cache directory
 		err := os.RemoveAll(goenv.Get("GOCACHE"))
@@ -1010,10 +906,10 @@ func main() {
 		usage()
 	case "version":
 		goversion := "<unknown>"
-		if s, err := goenv.GorootVersionString(goenv.Get("GOROOT")); err == nil {
+		if s, err := builder.GorootVersionString(goenv.Get("GOROOT")); err == nil {
 			goversion = s
 		}
-		fmt.Printf("tinygo version %s %s/%s (using go version %s and LLVM version %s)\n", goenv.Version, runtime.GOOS, runtime.GOARCH, goversion, llvm.Version)
+		fmt.Printf("tinygo version %s %s/%s (using go version %s and LLVM version %s)\n", version, runtime.GOOS, runtime.GOARCH, goversion, llvm.Version)
 	case "env":
 		if flag.NArg() == 0 {
 			// Show all environment variables.

main_test.go

@@ -73,7 +73,7 @@ func TestCompiler(t *testing.T) {
 		t.Run("ARM64Linux", func(t *testing.T) {
 			runPlatTests("aarch64--linux-gnu", matches, t)
 		})
-		goVersion, err := goenv.GorootVersionString(goenv.Get("GOROOT"))
+		goVersion, err := builder.GorootVersionString(goenv.Get("GOROOT"))
 		if err != nil {
 			t.Error("could not get Go version:", err)
 			return

src/device/arm/arm.go

@@ -196,7 +196,7 @@ func SetPriority(irq uint32, priority uint32) {
 func DisableInterrupts() uintptr {
 	return AsmFull(`
 		mrs {}, PRIMASK
-		cpsid i
+		cpsid if
 	`, nil)
 }
 

src/device/asm.go

@@ -1,21 +0,0 @@
-package device
-
-// Run the given assembly code. The code will be marked as having side effects,
-// as it doesn't produce output and thus would normally be eliminated by the
-// optimizer.
-func Asm(asm string)
-
-// Run the given inline assembly. The code will be marked as having side
-// effects, as it would otherwise be optimized away. The inline assembly string
-// recognizes template values in the form {name}, like so:
-//
-//     arm.AsmFull(
-//         "str {value}, {result}",
-//         map[string]interface{}{
-//             "value":  1
-//             "result": &dest,
-//         })
-//
-// You can use {} in the asm string (which expands to a register) to set the
-// return value.
-func AsmFull(asm string, regs map[string]interface{}) uintptr

src/device/riscv/riscv.go

@@ -19,19 +19,3 @@ func Asm(asm string)
 // You can use {} in the asm string (which expands to a register) to set the
 // return value.
 func AsmFull(asm string, regs map[string]interface{}) uintptr
-
-// DisableInterrupts disables all interrupts, and returns the old interrupt
-// state.
-func DisableInterrupts() uintptr {
-	// Note: this can be optimized with a CSRRW instruction, which atomically
-	// swaps the value and returns the old value.
-	mask := MIE.Get()
-	MIE.Set(0)
-	return mask
-}
-
-// EnableInterrupts enables all interrupts again. The value passed in must be
-// the mask returned by DisableInterrupts.
-func EnableInterrupts(mask uintptr) {
-	MIE.Set(mask)
-}

src/examples/button/button.go

@@ -5,14 +5,16 @@ import (
 	"time"
 )
 
+// This example assumes that the button is connected to pin 8. Change the value
+// below to use a different pin.
 const (
 	led    = machine.LED
-	button = machine.BUTTON
+	button = machine.Pin(8)
 )
 
 func main() {
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	button.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+	button.Configure(machine.PinConfig{Mode: machine.PinInput})
 
 	for {
 		if button.Get() {

src/examples/pininterrupt/circuitplay-express.go

@@ -1,10 +0,0 @@
-// +build circuitplay_express
-
-package main
-
-import "machine"
-
-const (
-	buttonMode      = machine.PinInputPulldown
-	buttonPinChange = machine.PinFalling
-)

src/examples/pininterrupt/pca10040.go

@@ -1,10 +0,0 @@
-// +build pca10040
-
-package main
-
-import "machine"
-
-const (
-	buttonMode      = machine.PinInputPullup
-	buttonPinChange = machine.PinRising
-)

src/examples/pininterrupt/pininterrupt.go

@@ -1,52 +0,0 @@
-package main
-
-// This example demonstrates how to use pin change interrupts.
-//
-// This is only an example and should not be copied directly in any serious
-// circuit, because it lacks an important feature: debouncing.
-// See: https://en.wikipedia.org/wiki/Switch#Contact_bounce
-
-import (
-	"machine"
-	"runtime/volatile"
-	"time"
-)
-
-const (
-	button = machine.BUTTON
-	led    = machine.LED
-)
-
-func main() {
-	var lightLed volatile.Register8
-	lightLed.Set(0)
-
-	// Configure the LED, defaulting to on (usually setting the pin to low will
-	// turn the LED on).
-	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	led.Low()
-
-	// Make sure the pin is configured as a pullup to avoid floating inputs.
-	// Pullup works for most buttons, as most buttons short to ground when
-	// pressed.
-	button.Configure(machine.PinConfig{Mode: buttonMode})
-
-	// Set an interrupt on this pin.
-	err := button.SetInterrupt(buttonPinChange, func(machine.Pin) {
-		if lightLed.Get() != 0 {
-			lightLed.Set(0)
-			led.Low()
-		} else {
-			lightLed.Set(1)
-			led.High()
-		}
-	})
-	if err != nil {
-		println("could not configure pin interrupt:", err.Error())
-	}
-
-	// Make sure the program won't exit.
-	for {
-		time.Sleep(time.Hour)
-	}
-}

src/examples/pininterrupt/wioterminal.go

@@ -1,10 +0,0 @@
-// +build wioterminal
-
-package main
-
-import "machine"
-
-const (
-	buttonMode      = machine.PinInput
-	buttonPinChange = machine.PinFalling
-)

src/examples/pwm/pwm.go

@@ -8,9 +8,9 @@ import (
 // This example assumes that an RGB LED is connected to pins 3, 5 and 6 on an Arduino.
 // Change the values below to use different pins.
 const (
-	redPin   = machine.D3
-	greenPin = machine.D5
-	bluePin  = machine.D6
+	redPin   = 3
+	greenPin = 5
+	bluePin  = 6
 )
 
 // cycleColor is just a placeholder until math/rand or some equivalent is working.
@@ -28,16 +28,13 @@ func main() {
 	machine.InitPWM()
 
 	red := machine.PWM{redPin}
-	err := red.Configure()
-	checkError(err, "failed to configure red pin")
+	red.Configure()
 
 	green := machine.PWM{greenPin}
-	err = green.Configure()
-	checkError(err, "failed to configure green pin")
+	green.Configure()
 
 	blue := machine.PWM{bluePin}
-	err = blue.Configure()
-	checkError(err, "failed to configure blue pin")
+	blue.Configure()
 
 	var rc uint8
 	var gc uint8 = 20
@@ -55,10 +52,3 @@ func main() {
 		time.Sleep(time.Millisecond * 500)
 	}
 }
-
-func checkError(err error, msg string) {
-	if err != nil {
-		print(msg, ": ", err.Error())
-		println()
-	}
-}

src/internal/bytealg/bytealg.go

@@ -1,126 +0,0 @@
-package bytealg
-
-const (
-	// Index can search any valid length of string.
-
-	MaxLen        = int(-1) >> 31
-	MaxBruteForce = MaxLen
-)
-
-// Compare two byte slices.
-// Returns -1 if the first differing byte is lower in a, or 1 if the first differing byte is greater in b.
-// If the byte slices are equal, returns 0.
-// If the lengths are different and there are no differing bytes, compares based on length.
-func Compare(a, b []byte) int {
-	// Compare for differing bytes.
-	for i := 0; i < len(a) && i < len(b); i++ {
-		switch {
-		case a[0] < b[0]:
-			return -1
-		case a[0] > b[0]:
-			return 1
-		}
-	}
-
-	// Compare lengths.
-	switch {
-	case len(a) > len(b):
-		return 1
-	case len(a) < len(b):
-		return -1
-	default:
-		return 0
-	}
-}
-
-// Count the number of instances of a byte in a slice.
-func Count(b []byte, c byte) int {
-	// Use a simple implementation, as there is no intrinsic that does this like we want.
-	n := 0
-	for _, v := range b {
-		if v == c {
-			n++
-		}
-	}
-	return n
-}
-
-// Count the number of instances of a byte in a string.
-func CountString(s string, c byte) int {
-	// Use a simple implementation, as there is no intrinsic that does this like we want.
-	// Currently, the compiler does not generate zero-copy byte-string conversions, so this needs to be seperate from Count.
-	n := 0
-	for i := 0; i < len(s); i++ {
-		if s[i] == c {
-			n++
-		}
-	}
-	return n
-}
-
-// Cutover is not reachable in TinyGo, but must exist as it is referenced.
-func Cutover(n int) int {
-	// Setting MaxLen and MaxBruteForce should force a different path to be taken.
-	// This should never be called.
-	panic("cutover is unreachable")
-}
-
-// Equal checks if two byte slices are equal.
-// It is equivalent to bytes.Equal.
-func Equal(a, b []byte) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i, v := range a {
-		if v != b[i] {
-			return false
-		}
-	}
-
-	return true
-}
-
-// Index finds the base index of the first instance of the byte sequence b in a.
-// If a does not contain b, this returns -1.
-func Index(a, b []byte) int {
-	for i := 0; i <= len(a)-len(b); i++ {
-		if Equal(a[i:i+len(b)], b) {
-			return i
-		}
-	}
-	return -1
-}
-
-// Index finds the index of the first instance of the specified byte in the slice.
-// If the byte is not found, this returns -1.
-func IndexByte(b []byte, c byte) int {
-	for i, v := range b {
-		if v == c {
-			return i
-		}
-	}
-	return -1
-}
-
-// Index finds the index of the first instance of the specified byte in the string.
-// If the byte is not found, this returns -1.
-func IndexByteString(s string, c byte) int {
-	for i := 0; i < len(s); i++ {
-		if s[i] == c {
-			return i
-		}
-	}
-	return -1
-}
-
-// Index finds the base index of the first instance of a substring in a string.
-// If the substring is not found, this returns -1.
-func IndexString(str, sub string) int {
-	for i := 0; i <= len(str)-len(sub); i++ {
-		if str[i:i+len(sub)] == sub {
-			return i
-		}
-	}
-	return -1
-}

src/internal/task/queue.go

@@ -68,8 +68,8 @@ func (s *Stack) Pop() *Task {
 	t := s.top
 	if t != nil {
 		s.top = t.Next
-		t.Next = nil
 	}
+	t.Next = nil
 	return t
 }
 

src/internal/task/task_coroutine.go

@@ -85,14 +85,9 @@ type taskHolder interface {
 	getReturnPtr() unsafe.Pointer
 }
 
-// If there are no direct references to the task methods, they will not be discovered by the compiler, and this will trigger a compiler error.
-// Instantiating this interface forces discovery of these methods.
-var _ = taskHolder((*Task)(nil))
-
 func fake() {
 	// Hack to ensure intrinsics are discovered.
 	Current()
-	go func() {}()
 	Pause()
 }
 

src/internal/task/task_stack_avr.go

@@ -4,7 +4,7 @@ package task
 
 import "unsafe"
 
-const stackSize = 1024
+const stackSize = 256
 
 // 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

src/machine/board_arduino.go

@@ -7,39 +7,21 @@ func CPUFrequency() uint32 {
 	return 16000000
 }
 
-// Digital pins, marked as plain numbers on the board.
-const (
-	D0  = PD0 // RX
-	D1  = PD1 // TX
-	D2  = PD2
-	D3  = PD3
-	D4  = PD4
-	D5  = PD5
-	D6  = PD6
-	D7  = PD7
-	D8  = PB0
-	D9  = PB1
-	D10 = PB2
-	D11 = PB3
-	D12 = PB4
-	D13 = PB5
-)
-
 // LED on the Arduino
-const LED Pin = D13
+const LED Pin = 13
 
 // ADC on the Arduino
 const (
-	ADC0 Pin = PC0
-	ADC1 Pin = PC1
-	ADC2 Pin = PC2
-	ADC3 Pin = PC3
-	ADC4 Pin = PC4 // Used by TWI for SDA
-	ADC5 Pin = PC5 // Used by TWI for SCL
+	ADC0 Pin = 0
+	ADC1 Pin = 1
+	ADC2 Pin = 2
+	ADC3 Pin = 3
+	ADC4 Pin = 4 // Used by TWI for SDA
+	ADC5 Pin = 5 // Used by TWI for SCL
 )
 
 // UART pins
 const (
-	UART_TX_PIN Pin = PD1
-	UART_RX_PIN Pin = PD0
+	UART_TX_PIN Pin = 1
+	UART_RX_PIN Pin = 0
 )

src/machine/board_arduino_nano.go

@@ -7,39 +7,21 @@ func CPUFrequency() uint32 {
 	return 16000000
 }
 
-// Digital pins.
-const (
-	D0  = PD0 // RX0
-	D1  = PD1 // TX1
-	D2  = PD2
-	D3  = PD3
-	D4  = PD4
-	D5  = PD5
-	D6  = PD6
-	D7  = PD7
-	D8  = PB0
-	D9  = PB1
-	D10 = PB2
-	D11 = PB3
-	D12 = PB4
-	D13 = PB5
-)
-
 // LED on the Arduino
-const LED Pin = D13
+const LED Pin = 13
 
 // ADC on the Arduino
 const (
-	ADC0 Pin = PC0
-	ADC1 Pin = PC1
-	ADC2 Pin = PC2
-	ADC3 Pin = PC3
-	ADC4 Pin = PC4 // Used by TWI for SDA
-	ADC5 Pin = PC5 // Used by TWI for SCL
+	ADC0 Pin = 0
+	ADC1 Pin = 1
+	ADC2 Pin = 2
+	ADC3 Pin = 3
+	ADC4 Pin = 4 // Used by TWI for SDA
+	ADC5 Pin = 5 // Used by TWI for SCL
 )
 
 // UART pins
 const (
-	UART_TX_PIN Pin = PD1
-	UART_RX_PIN Pin = PD0
+	UART_TX_PIN Pin = 1
+	UART_RX_PIN Pin = 0
 )

src/machine/board_atmega328p.go

@@ -1,37 +0,0 @@
-// +build avr,atmega328p arduino arduino_nano
-
-package machine
-
-const (
-	// Note: start at port B because there is no port A.
-	portB Pin = iota * 8
-	portC
-	portD
-)
-
-const (
-	PB0 = portB + 0
-	PB1 = portB + 1
-	PB2 = portB + 2
-	PB3 = portB + 3
-	PB4 = portB + 4
-	PB5 = portB + 5
-	PB6 = portB + 6
-	PB7 = portB + 7
-	PC0 = portC + 0
-	PC1 = portC + 1
-	PC2 = portC + 2
-	PC3 = portC + 3
-	PC4 = portC + 4
-	PC5 = portC + 5
-	PC6 = portC + 6
-	PC7 = portC + 7
-	PD0 = portD + 0
-	PD1 = portD + 1
-	PD2 = portD + 2
-	PD3 = portD + 3
-	PD4 = portD + 4
-	PD5 = portD + 5
-	PD6 = portD + 6
-	PD7 = portD + 7
-)

src/machine/board_feather-m4.go

@@ -1,7 +1,9 @@
-// +build feather_m4
+// +build sam,atsamd51,feather_m4
 
 package machine
 
+import "device/sam"
+
 // used to reset into bootloader
 const RESET_MAGIC_VALUE = 0xf01669ef
 
@@ -45,11 +47,13 @@ const (
 	USBCDC_DP_PIN = PA25
 )
 
+// UART1 pins
 const (
 	UART_TX_PIN = D1
 	UART_RX_PIN = D0
 )
 
+// UART2 pins
 const (
 	UART2_TX_PIN = A4
 	UART2_RX_PIN = A5
@@ -61,6 +65,14 @@ const (
 	SCL_PIN = D21 // SCL: SERCOM2/PAD[1]
 )
 
+// I2C on the Feather M4.
+var (
+	I2C0 = I2C{
+		Bus:    sam.SERCOM2_I2CM,
+		SERCOM: 2,
+	}
+)
+
 // SPI pins
 const (
 	SPI0_SCK_PIN  = D25 // SCK: SERCOM1/PAD[1]
@@ -68,6 +80,14 @@ const (
 	SPI0_MISO_PIN = D23 // MISO: SERCOM1/PAD[2]
 )
 
+// SPI on the Feather M4.
+var (
+	SPI0 = SPI{
+		Bus:    sam.SERCOM1_SPIM,
+		SERCOM: 1,
+	}
+)
+
 // USB CDC identifiers
 const (
 	usb_STRING_PRODUCT      = "Adafruit Feather M4"

src/machine/board_feather-m4_baremetal.go

@@ -1,43 +0,0 @@
-// +build sam,atsamd51,feather_m4
-
-package machine
-
-import (
-	"device/sam"
-	"runtime/interrupt"
-)
-
-var (
-	UART1 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM5_USART_INT,
-		SERCOM: 5,
-	}
-
-	UART2 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM0_USART_INT,
-		SERCOM: 0,
-	}
-)
-
-func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART2.handleInterrupt)
-}
-
-// I2C on the Feather M4.
-var (
-	I2C0 = I2C{
-		Bus:    sam.SERCOM2_I2CM,
-		SERCOM: 2,
-	}
-)
-
-// SPI on the Feather M4.
-var (
-	SPI0 = SPI{
-		Bus:    sam.SERCOM1_SPIM,
-		SERCOM: 1,
-	}
-)

src/machine/board_hifive1b.go

@@ -37,8 +37,8 @@ const (
 
 const (
 	// TODO: figure out the pin numbers for these.
-	UART_TX_PIN = D1
-	UART_RX_PIN = D0
+	UART_TX_PIN = NoPin
+	UART_RX_PIN = NoPin
 )
 
 // SPI pins

src/machine/board_itsybitsy-m4.go

@@ -1,7 +1,9 @@
-// +build itsybitsy_m4
+// +build sam,atsamd51,itsybitsy_m4
 
 package machine
 
+import "device/sam"
+
 // used to reset into bootloader
 const RESET_MAGIC_VALUE = 0xf01669ef
 
@@ -49,17 +51,30 @@ const (
 	UART_RX_PIN = D0
 )
 
+// UART1 var is on SERCOM3, defined in atsamd51.go
+
+// UART2 pins
 const (
 	UART2_TX_PIN = A4
 	UART2_RX_PIN = D2
 )
 
+// UART2 var is on SERCOM0, defined in atsamd51.go
+
 // I2C pins
 const (
 	SDA_PIN = PA12 // SDA: SERCOM2/PAD[0]
 	SCL_PIN = PA13 // SCL: SERCOM2/PAD[1]
 )
 
+// I2C on the ItsyBitsy M4.
+var (
+	I2C0 = I2C{
+		Bus:    sam.SERCOM2_I2CM,
+		SERCOM: 2,
+	}
+)
+
 // SPI pins
 const (
 	SPI0_SCK_PIN  = PA01 // SCK: SERCOM1/PAD[1]
@@ -67,6 +82,14 @@ const (
 	SPI0_MISO_PIN = PB23 // MISO: SERCOM1/PAD[3]
 )
 
+// SPI on the ItsyBitsy M4.
+var (
+	SPI0 = SPI{
+		Bus:    sam.SERCOM1_SPIM,
+		SERCOM: 1,
+	}
+)
+
 // USB CDC identifiers
 const (
 	usb_STRING_PRODUCT      = "Adafruit ItsyBitsy M4"

src/machine/board_itsybitsy-m4_baremetal.go

@@ -1,43 +0,0 @@
-// +build sam,atsamd51,itsybitsy_m4
-
-package machine
-
-import (
-	"device/sam"
-	"runtime/interrupt"
-)
-
-var (
-	UART1 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM3_USART_INT,
-		SERCOM: 3,
-	}
-
-	UART2 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM0_USART_INT,
-		SERCOM: 0,
-	}
-)
-
-func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM3_2, UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART2.handleInterrupt)
-}
-
-// I2C on the ItsyBitsy M4.
-var (
-	I2C0 = I2C{
-		Bus:    sam.SERCOM2_I2CM,
-		SERCOM: 2,
-	}
-)
-
-// SPI on the ItsyBitsy M4.
-var (
-	SPI0 = SPI{
-		Bus:    sam.SERCOM1_SPIM,
-		SERCOM: 1,
-	}
-)

src/machine/board_metro-m4-airlift.go

@@ -1,7 +1,9 @@
-// +build metro_m4_airlift
+// +build sam,atsamd51,metro_m4_airlift
 
 package machine
 
+import "device/sam"
+
 // used to reset into bootloader
 const RESET_MAGIC_VALUE = 0xf01669ef
 
@@ -51,10 +53,7 @@ const (
 	UART_RX_PIN = D0
 )
 
-const (
-	UART2_TX_PIN = PA04
-	UART2_RX_PIN = PA07
-)
+// Note: UART1 is on SERCOM3, defined in machine_atsamd51.go
 
 const (
 	NINA_CS     = PA15
@@ -67,12 +66,23 @@ const (
 	NINA_RTS = PB23
 )
 
+// UART2 is on SERCOM0,  defined in machine_atsamd51.go, and connects to the
+// onboard ESP32-WROOM chip.
+
 // I2C pins
 const (
 	SDA_PIN = PB02 // SDA: SERCOM5/PAD[0]
 	SCL_PIN = PB03 // SCL: SERCOM5/PAD[1]
 )
 
+// I2C on the Metro M4.
+var (
+	I2C0 = I2C{
+		Bus:    sam.SERCOM5_I2CM,
+		SERCOM: 5,
+	}
+)
+
 // SPI pins
 const (
 	SPI0_SCK_PIN  = PA13 // SCK:  SERCOM2/PAD[1]
@@ -84,12 +94,29 @@ const (
 	NINA_SCK  = SPI0_SCK_PIN
 )
 
+// SPI on the Metro M4.
+var (
+	SPI0 = SPI{
+		Bus:    sam.SERCOM2_SPIM,
+		SERCOM: 2,
+	}
+	NINA_SPI = SPI0
+)
+
 const (
 	SPI1_SCK_PIN  = D12 // MISO: SERCOM1/PAD[1]
 	SPI1_MOSI_PIN = D11 // MOSI: SERCOM1/PAD[3]
 	SPI1_MISO_PIN = D13 // SCK:  SERCOM1/PAD[0]
 )
 
+// SPI1 on the Metro M4 on pins 11,12,13
+var (
+	SPI1 = SPI{
+		Bus:    sam.SERCOM1_SPIM,
+		SERCOM: 1,
+	}
+)
+
 // USB CDC identifiers
 const (
 	usb_STRING_PRODUCT      = "Adafruit Metro M4 Airlift Lite"

src/machine/board_metro-m4-airlift_baremetal.go

@@ -1,52 +0,0 @@
-// +build sam,atsamd51,metro_m4_airlift
-
-package machine
-
-import (
-	"device/sam"
-	"runtime/interrupt"
-)
-
-var (
-	UART1 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM3_USART_INT,
-		SERCOM: 3,
-	}
-
-	UART2 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM0_USART_INT,
-		SERCOM: 0,
-	}
-)
-
-func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM3_2, UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART2.handleInterrupt)
-}
-
-// I2C on the Metro M4.
-var (
-	I2C0 = I2C{
-		Bus:    sam.SERCOM5_I2CM,
-		SERCOM: 5,
-	}
-)
-
-// SPI on the Metro M4.
-var (
-	SPI0 = SPI{
-		Bus:    sam.SERCOM2_SPIM,
-		SERCOM: 2,
-	}
-	NINA_SPI = SPI0
-)
-
-// SPI1 on the Metro M4 on pins 11,12,13
-var (
-	SPI1 = SPI{
-		Bus:    sam.SERCOM1_SPIM,
-		SERCOM: 1,
-	}
-)

src/machine/board_pybadge.go

@@ -1,7 +1,9 @@
-// +build pybadge
+// +build sam,atsamd51,pybadge
 
 package machine
 
+import "device/sam"
+
 // used to reset into bootloader
 const RESET_MAGIC_VALUE = 0xf01669ef
 
@@ -78,17 +80,30 @@ const (
 	UART_RX_PIN = D0
 )
 
+// UART1 var is on SERCOM3, defined in atsamd51.go
+
+// UART2 pins
 const (
 	UART2_TX_PIN = A4
 	UART2_RX_PIN = A5
 )
 
+// UART2 var is on SERCOM0, defined in atsamd51.go
+
 // I2C pins
 const (
 	SDA_PIN = PA12 // SDA: SERCOM2/PAD[0]
 	SCL_PIN = PA13 // SCL: SERCOM2/PAD[1]
 )
 
+// I2C on the ItsyBitsy M4.
+var (
+	I2C0 = I2C{
+		Bus:    sam.SERCOM2_I2CM,
+		SERCOM: 2,
+	}
+)
+
 // SPI pins
 const (
 	SPI0_SCK_PIN  = PA17 // SCK: SERCOM1/PAD[1]
@@ -96,6 +111,14 @@ const (
 	SPI0_MISO_PIN = PB22 // MISO: SERCOM1/PAD[2]
 )
 
+// SPI on the PyBadge.
+var (
+	SPI0 = SPI{
+		Bus:    sam.SERCOM1_SPIM,
+		SERCOM: 1,
+	}
+)
+
 // TFT SPI pins
 const (
 	SPI1_SCK_PIN  = PB13 // SCK: SERCOM4/PAD[1]
@@ -103,6 +126,14 @@ const (
 	SPI1_MISO_PIN = NoPin
 )
 
+// TFT SPI on the PyBadge.
+var (
+	SPI1 = SPI{
+		Bus:    sam.SERCOM4_SPIM,
+		SERCOM: 4,
+	}
+)
+
 // USB CDC identifiers
 const (
 	usb_STRING_PRODUCT      = "Adafruit pyBadge M4"

src/machine/board_pybadge_baremetal.go

@@ -1,51 +0,0 @@
-// +build sam,atsamd51,pybadge
-
-package machine
-
-import (
-	"device/sam"
-	"runtime/interrupt"
-)
-
-var (
-	UART1 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM5_USART_INT,
-		SERCOM: 5,
-	}
-
-	UART2 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM0_USART_INT,
-		SERCOM: 0,
-	}
-)
-
-func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM5_2, UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART2.handleInterrupt)
-}
-
-// I2C on the ItsyBitsy M4.
-var (
-	I2C0 = I2C{
-		Bus:    sam.SERCOM2_I2CM,
-		SERCOM: 2,
-	}
-)
-
-// SPI on the PyBadge.
-var (
-	SPI0 = SPI{
-		Bus:    sam.SERCOM1_SPIM,
-		SERCOM: 1,
-	}
-)
-
-// TFT SPI on the PyBadge.
-var (
-	SPI1 = SPI{
-		Bus:    sam.SERCOM4_SPIM,
-		SERCOM: 4,
-	}
-)

src/machine/board_pygamer.go

@@ -1,147 +0,0 @@
-// +build sam,atsamd51,pygamer
-
-package machine
-
-import "device/sam"
-
-// used to reset into bootloader
-const RESET_MAGIC_VALUE = 0xf01669ef
-
-// GPIO Pins
-const (
-	D0  = PB17 // UART0 RX/PWM available
-	D1  = PB16 // UART0 TX/PWM available
-	D2  = PB03
-	D3  = PB02
-	D4  = PA14 // PWM available
-	D5  = PA16 // PWM available
-	D6  = PA18 // PWM available
-	D7  = PB14 // CS for microSD card slot
-	D8  = PA15 // built-in neopixel
-	D9  = PA19 // PWM available
-	D10 = PA20 // can be used for PWM or UART1 TX
-	D11 = PA21 // can be used for PWM or UART1 RX
-	D12 = PA22 // PWM available
-	D13 = PA23 // PWM available
-)
-
-// Analog pins
-const (
-	A0 = PA02 // ADC/AIN[0]
-	A1 = PA05 // ADC/AIN[2]
-	A2 = PB08 // ADC/AIN[3]
-	A3 = PB09 // ADC/AIN[4]
-	A4 = PA04 // ADC/AIN[5]
-	A5 = PA06 // ADC/AIN[6]
-	A6 = PB01 // ADC/AIN[12]/VMEAS
-	A7 = PB04 // ADC/AIN[6]/LIGHT
-	A8 = D2   // ADC/AIN[14]
-	A9 = D3   // ADC/AIN[15]
-)
-
-const (
-	LED       = D13
-	NEOPIXELS = D8
-
-	SD_CS = D7
-
-	LIGHTSENSOR = A7
-
-	BUTTON_LATCH = PB00
-	BUTTON_OUT   = PB30
-	BUTTON_CLK   = PB31
-
-	JOYY = PB06
-	JOYX = PB07
-
-	TFT_DC   = PB05
-	TFT_CS   = PB12
-	TFT_RST  = PA00
-	TFT_LITE = PA01
-
-	SPEAKER_ENABLE = PA27
-)
-
-const (
-	BUTTON_SELECT_MASK = 16
-	BUTTON_START_MASK  = 32
-	BUTTON_A_MASK      = 64
-	BUTTON_B_MASK      = 128
-)
-
-// UART0 aka USBCDC pins
-const (
-	USBCDC_DM_PIN = PA24
-	USBCDC_DP_PIN = PA25
-)
-
-// UART1 pins
-const (
-	UART_TX_PIN = D1
-	UART_RX_PIN = D0
-)
-
-// UART1 var is on SERCOM3, defined in atsamd51.go
-
-// UART2 pins
-const (
-	UART2_TX_PIN = A4
-	UART2_RX_PIN = A5
-)
-
-// UART2 var is on SERCOM0, defined in atsamd51.go
-
-// I2C pins
-const (
-	SDA_PIN = PA12 // SDA: SERCOM2/PAD[0]
-	SCL_PIN = PA13 // SCL: SERCOM2/PAD[1]
-)
-
-// I2C on the PyGamer.
-var (
-	I2C0 = I2C{
-		Bus:    sam.SERCOM2_I2CM,
-		SERCOM: 2,
-	}
-)
-
-// SPI pins
-const (
-	SPI0_SCK_PIN  = PA17 // SCK: SERCOM1/PAD[1]
-	SPI0_MOSI_PIN = PB23 // MOSI: SERCOM1/PAD[3]
-	SPI0_MISO_PIN = PB22 // MISO: SERCOM1/PAD[2]
-)
-
-// SPI on the PyGamer.
-var (
-	SPI0 = SPI{
-		Bus:    sam.SERCOM1_SPIM,
-		SERCOM: 1,
-	}
-)
-
-// TFT SPI pins
-const (
-	SPI1_SCK_PIN  = PB13 // SCK: SERCOM4/PAD[1]
-	SPI1_MOSI_PIN = PB15 // MOSI: SERCOM4/PAD[3]
-	SPI1_MISO_PIN = NoPin
-)
-
-// TFT SPI on the PyGamer.
-var (
-	SPI1 = SPI{
-		Bus:    sam.SERCOM4_SPIM,
-		SERCOM: 4,
-	}
-)
-
-// USB CDC identifiers
-const (
-	usb_STRING_PRODUCT      = "Adafruit pyGamer M4"
-	usb_STRING_MANUFACTURER = "Adafruit"
-)
-
-var (
-	usb_VID uint16 = 0x239A
-	usb_PID uint16 = 0x8033
-)

src/machine/board_pyportal.go

@@ -1,7 +1,11 @@
-// +build pyportal
+// +build sam,atsamd51,pyportal
 
 package machine
 
+import (
+	"device/sam"
+)
+
 // used to reset into bootloader
 const RESET_MAGIC_VALUE = 0xf01669ef
 
@@ -100,10 +104,10 @@ const (
 	USBCDC_DP_PIN = PA25
 )
 
-// UART1 aka NINA_TX/NINA_RX
+// TODO: add configuration for UART on SERCOM4 that is connected to TX/RX of ESP32
 const (
-	UART_TX_PIN = D1
-	UART_RX_PIN = D0
+	UART_TX_PIN = NoPin
+	UART_RX_PIN = NoPin
 )
 
 // I2C pins
@@ -112,6 +116,14 @@ const (
 	SCL_PIN = PB03 // SCL: SERCOM2/PAD[1]
 )
 
+// I2C on the PyPortal.
+var (
+	I2C0 = I2C{
+		Bus:    sam.SERCOM5_I2CM,
+		SERCOM: 5,
+	}
+)
+
 // SPI pins
 const (
 	SPI0_SCK_PIN  = PA13 // SCK: SERCOM1/PAD[1]
@@ -123,6 +135,15 @@ const (
 	NINA_SCK  = SPI0_SCK_PIN
 )
 
+// SPI on the PyPortal.
+var (
+	SPI0 = SPI{
+		Bus:    sam.SERCOM2_SPIM,
+		SERCOM: 2,
+	}
+	NINA_SPI = SPI0
+)
+
 // USB CDC identifiers
 const (
 	usb_STRING_PRODUCT      = "Adafruit PyPortal M4"

src/machine/board_pyportal_baremetal.go

@@ -1,37 +0,0 @@
-// +build sam,atsamd51,pyportal
-
-package machine
-
-import (
-	"device/sam"
-	"runtime/interrupt"
-)
-
-var (
-	UART1 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM4_USART_INT,
-		SERCOM: 4,
-	}
-)
-
-func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM4_2, UART1.handleInterrupt)
-}
-
-// I2C on the PyPortal.
-var (
-	I2C0 = I2C{
-		Bus:    sam.SERCOM5_I2CM,
-		SERCOM: 5,
-	}
-)
-
-// SPI on the PyPortal.
-var (
-	SPI0 = SPI{
-		Bus:    sam.SERCOM2_SPIM,
-		SERCOM: 2,
-	}
-	NINA_SPI = SPI0
-)

src/machine/board_wioterminal.go

@@ -1,392 +0,0 @@
-// +build wioterminal
-
-package machine
-
-// used to reset into bootloader
-const RESET_MAGIC_VALUE = 0xf01669ef
-
-const (
-	ADC0 = A0
-	ADC1 = A1
-	ADC2 = A2
-	ADC3 = A3
-	ADC4 = A4
-	ADC5 = A5
-	ADC6 = A6
-	ADC7 = A7
-	ADC8 = A8
-
-	LED    = PIN_LED
-	BUTTON = BUTTON_1
-)
-
-const (
-	// https://github.com/Seeed-Studio/ArduinoCore-samd/blob/master/variants/wio_terminal/variant.h
-
-	// LEDs
-	PIN_LED_13   = PA15
-	PIN_LED_RXL  = PA15
-	PIN_LED_TXL  = PA15
-	PIN_LED      = PIN_LED_13
-	PIN_LED2     = PIN_LED_RXL
-	PIN_LED3     = PIN_LED_TXL
-	LED_BUILTIN  = PIN_LED_13
-	PIN_NEOPIXEL = PA15
-
-	//Digital PINs
-	D0 = PB08
-	D1 = PB09
-	D2 = PA07
-	D3 = PB04
-	D4 = PB05
-	D5 = PB06
-	D6 = PA04
-	D7 = PB07
-	D8 = PA06
-
-	//Analog PINs
-	A0 = PB08 // ADC/AIN[0]
-	A1 = PB09 // ADC/AIN[2]
-	A2 = PA07 // ADC/AIN[3]
-	A3 = PB04 // ADC/AIN[4]
-	A4 = PB05 // ADC/AIN[5]
-	A5 = PB06 // ADC/AIN[10]
-	A6 = PA04 // ADC/AIN[10]
-	A7 = PB07 // ADC/AIN[10]
-	A8 = PA06 // ADC/AIN[10]
-
-	// 3.3V    ||    5V
-	// BCM2    ||    5V
-	// BCM3    ||    GND
-	// BCM4    ||    BCM14
-	// GND     ||    BCM15
-	// BCM17   ||    BCM18
-	// BCM27   ||    GND
-	// BCM22   ||    BCM23
-	// GND     ||    BCM24
-	// BCM10   ||    GND
-	// BCM9    ||    BCM25
-	// BCM11   ||    BCM8
-	// GND     ||    BCM7
-	// BCM0    ||    BCM1
-	// BCM5    ||    GND
-	// BCM6    ||    BCM12
-	// BCM13   ||    GND
-	// BCM19   ||    BCM16
-	// BCM26   ||    BCM20
-	// GND     ||    BCM21
-
-	//PIN DEFINE FOR RPI
-	BCM0  = PA13 // I2C Wire1
-	BCM1  = PA12 // I2C Wire1
-	BCM2  = PA17 // I2C Wire2
-	BCM3  = PA16 // I2C Wire2
-	BCM4  = PB14 // GCLK
-	BCM5  = PB12 // GCLK
-	BCM6  = PB13 // GCLK
-	BCM7  = PA05 // DAC1
-	BCM8  = PB01 // SPI SS
-	BCM9  = PB00 // SPI MISO
-	BCM10 = PB02 // SPI MOSI
-	BCM11 = PB03 // SPI SCK
-	BCM12 = PB06
-	BCM13 = PA07
-	BCM14 = PB27 // UART Serial1
-	BCM15 = PB26 // UART Serial1
-	BCM16 = PB07
-	BCM17 = PA02 // DAC0
-	BCM18 = PB28 // FPC Digital & AD pins
-	BCM19 = PA20 // WIO_IR
-	BCM20 = PA21 // I2S SDO
-	BCM21 = PA22 // I2S SDI
-	BCM22 = PB09
-	BCM23 = PA07
-	BCM24 = PB04
-	BCM25 = PB05
-	BCM26 = PA06
-	BCM27 = PB08
-
-	// FPC NEW DEFINE
-	FPC1  = PB28 // FPC Digital & AD pins
-	FPC2  = PB17
-	FPC3  = PB29
-	FPC4  = PA14
-	FPC5  = PC01
-	FPC6  = PC02
-	FPC7  = PC03
-	FPC8  = PC04
-	FPC9  = PC31
-	FPC10 = PD00
-
-	// RPI Analog RPIs
-	RPI_A0 = PB08
-	RPI_A1 = PB09
-	RPI_A2 = PA07
-	RPI_A3 = PB04
-	RPI_A4 = PB05
-	RPI_A5 = PB06
-	RPI_A6 = PA04
-	RPI_A7 = PB07
-	RPI_A8 = PA06
-
-	PIN_DAC0 = PA02
-	PIN_DAC1 = PA05
-
-	DAC0 = PIN_DAC0
-	DAC1 = PIN_DAC1
-
-	// FPO Analog RPIs
-	//FPC_A7  = FPC_D7
-	//FPC_A8  = FPC_D8
-	//FPC_A9  = FPC_D9
-	//FPC_A11 = FPC_D11
-	//FPC_A12 = FPC_D12
-	//FPC_A13 = FPC_D13
-
-	// USB
-	PIN_USB_DM          = PA24
-	PIN_USB_DP          = PA25
-	PIN_USB_HOST_ENABLE = PA27
-
-	// BUTTON
-	BUTTON_1  = PC26
-	BUTTON_2  = PC27
-	BUTTON_3  = PC28
-	WIO_KEY_A = PC26
-	WIO_KEY_B = PC27
-	WIO_KEY_C = PC28
-
-	// SWITCH
-	SWITCH_X = PD20
-	SWITCH_Y = PD12
-	SWITCH_Z = PD09
-	SWITCH_B = PD08
-	SWITCH_U = PD10
-
-	WIO_5S_UP    = PD20
-	WIO_5S_LEFT  = PD12
-	WIO_5S_RIGHT = PD09
-	WIO_5S_DOWN  = PD08
-	WIO_5S_PRESS = PD10
-
-	// IRQ0 : RTL8720D
-	IRQ0 = PC20
-
-	// BUZZER_CTR
-	BUZZER_CTR = PD11
-	WIO_BUZZER = PD11
-
-	// MIC_INPUT
-	MIC_INPUT = PC30
-	WIO_MIC   = PC30
-
-	// GCLK
-	GCLK0 = PB14
-	GCLK1 = PB12
-	GCLK2 = PB13
-
-	// Serial interfaces
-	// Serial1
-	PIN_SERIAL1_RX = PB27
-	PIN_SERIAL1_TX = PB26
-
-	// Serial2 : RTL8720D
-	PIN_SERIAL2_RX = PC23
-	PIN_SERIAL2_TX = PC22
-
-	// Wire Interfaces
-	// I2C Wire2
-	// I2C1
-	PIN_WIRE_SDA = PA17
-	PIN_WIRE_SCL = PA16
-	SDA          = PIN_WIRE_SDA
-	SCL          = PIN_WIRE_SCL
-
-	// I2C Wire1
-	// I2C0 : LIS3DHTR and ATECC608
-	PIN_WIRE1_SDA = PA13
-	PIN_WIRE1_SCL = PA12
-
-	SDA1 = PIN_WIRE1_SDA
-	SCL1 = PIN_WIRE1_SCL
-
-	PIN_GYROSCOPE_WIRE_SDA = PIN_WIRE1_SDA
-	PIN_GYROSCOPE_WIRE_SCL = PIN_WIRE1_SCL
-	GYROSCOPE_INT1         = PC21
-
-	WIO_LIS3DH_SDA = PIN_WIRE1_SDA
-	WIO_LIS3DH_SCL = PIN_WIRE1_SCL
-	WIO_LIS3DH_INT = PC21
-
-	// SPI
-	PIN_SPI_MISO = PB00
-	PIN_SPI_MOSI = PB02
-	PIN_SPI_SCK  = PB03
-	PIN_SPI_SS   = PB01
-
-	SS   = PIN_SPI_SS
-	MOSI = PIN_SPI_MOSI
-	MISO = PIN_SPI_MISO
-	SCK  = PIN_SPI_SCK
-
-	// SPI1 RTL8720D_SPI
-	PIN_SPI1_MISO = PC24
-	PIN_SPI1_MOSI = PB24
-	PIN_SPI1_SCK  = PB25
-	PIN_SPI1_SS   = PC25
-
-	SS1   = PIN_SPI1_SS
-	MOSI1 = PIN_SPI1_MOSI
-	MISO1 = PIN_SPI1_MISO
-	SCK1  = PIN_SPI1_SCK
-
-	// SPI2 SD_SPI
-	PIN_SPI2_MISO = PC18
-	PIN_SPI2_MOSI = PC16
-	PIN_SPI2_SCK  = PC17
-	PIN_SPI2_SS   = PC19
-
-	SS2   = PIN_SPI2_SS
-	MOSI2 = PIN_SPI2_MOSI
-	MISO2 = PIN_SPI2_MISO
-	SCK2  = PIN_SPI2_SCK
-
-	// SPI3 LCD_SPI
-	PIN_SPI3_MISO = PB18
-	PIN_SPI3_MOSI = PB19
-	PIN_SPI3_SCK  = PB20
-	PIN_SPI3_SS   = PB21
-
-	SS3   = PIN_SPI3_SS
-	MOSI3 = PIN_SPI3_MOSI
-	MISO3 = PIN_SPI3_MISO
-	SCK3  = PIN_SPI3_SCK
-
-	// Needed for SD library
-	SDCARD_MISO_PIN = PIN_SPI2_MISO
-	SDCARD_MOSI_PIN = PIN_SPI2_MOSI
-	SDCARD_SCK_PIN  = PIN_SPI2_SCK
-	SDCARD_SS_PIN   = PIN_SPI2_SS
-	SDCARD_DET_PIN  = PD21
-
-	LCD_MISO_PIN  = PIN_SPI3_MISO
-	LCD_MOSI_PIN  = PIN_SPI3_MOSI
-	LCD_SCK_PIN   = PIN_SPI3_SCK
-	LCD_SS_PIN    = PIN_SPI3_SS
-	LCD_DC        = PC06
-	LCD_RESET     = PC07
-	LCD_BACKLIGHT = PC05
-
-	// 4 WIRE LCD TOUCH
-	LCD_XL = PC10
-	LCD_YU = PC11
-	LCD_XR = PC12
-	LCD_YD = PC13
-
-	// Needed for RTL8720D
-	RTL8720D_MISO_PIN = PIN_SPI1_MISO
-	RTL8720D_MOSI_PIN = PIN_SPI1_MOSI
-	RTL8720D_SCK_PIN  = PIN_SPI1_SCK
-	RTL8720D_SS_PIN   = PIN_SPI1_SS
-
-	//QSPI Pins
-	PIN_QSPI_IO0 = PA08
-	PIN_QSPI_IO1 = PA09
-	PIN_QSPI_IO2 = PA10
-	PIN_QSPI_IO3 = PA11
-	PIN_QSPI_SCK = PB10
-	PIN_QSPI_CS  = PB11
-
-	// I2S Interfaces
-	PIN_I2S_FS  = PA20
-	PIN_I2S_SCK = PB16
-	PIN_I2S_SDO = PA22
-	PIN_I2S_SDI = PA21
-
-	I2S_LRCLK = PA20
-	I2S_BLCK  = PB16
-	I2S_SDOUT = PA22
-	I2S_SDIN  = PA21
-
-	// RTL8720D Interfaces
-	RTL8720D_CHIP_PU = PA18
-	RTL8720D_GPIO0   = PA19 // SYNC
-
-	// SWD
-	SWDCLK = PA30
-	SWDIO  = PA31
-	SWO    = PB30
-
-	// light sensor
-	WIO_LIGHT = PD01
-
-	// ir sensor
-	WIO_IR = PB31
-
-	// OUTPUT_CTR
-	OUTPUT_CTR_5V  = PC14
-	OUTPUT_CTR_3V3 = PC15
-)
-
-// UART0 aka USBCDC pins
-const (
-	USBCDC_DM_PIN = PIN_USB_DM
-	USBCDC_DP_PIN = PIN_USB_DP
-)
-
-// UART1 pins
-const (
-	UART_TX_PIN = PIN_SERIAL1_TX
-	UART_RX_PIN = PIN_SERIAL1_RX
-)
-
-// UART2 pins RTL8720D
-const (
-	UART2_TX_PIN = PIN_SERIAL2_TX
-	UART2_RX_PIN = PIN_SERIAL2_RX
-)
-
-// I2C pins
-const (
-	SDA0_PIN = PIN_WIRE_SDA // SDA: SERCOM3/PAD[0]
-	SCL0_PIN = PIN_WIRE_SCL // SCL: SERCOM3/PAD[1]
-
-	SDA1_PIN = PIN_WIRE1_SDA // SDA: SERCOM4/PAD[0]
-	SCL1_PIN = PIN_WIRE1_SCL // SCL: SERCOM4/PAD[1]
-
-	SDA_PIN = SDA0_PIN
-	SCL_PIN = SCL0_PIN
-)
-
-// SPI pins
-const (
-	SPI0_SCK_PIN  = SCK  // SCK:  SERCOM5/PAD[1]
-	SPI0_MOSI_PIN = MOSI // MOSI: SERCOM5/PAD[0]
-	SPI0_MISO_PIN = MISO // MISO: SERCOM5/PAD[2]
-
-	// RTL8720D
-	SPI1_SCK_PIN  = SCK1  // SCK:  SERCOM0/PAD[1]
-	SPI1_MOSI_PIN = MOSI1 // MOSI: SERCOM0/PAD[0]
-	SPI1_MISO_PIN = MISO1 // MISO: SERCOM0/PAD[2]
-
-	// SD
-	SPI2_SCK_PIN  = SCK2  // SCK:  SERCOM6/PAD[1]
-	SPI2_MOSI_PIN = MOSI2 // MOSI: SERCOM6/PAD[0]
-	SPI2_MISO_PIN = MISO2 // MISO: SERCOM6/PAD[2]
-
-	// LCD
-	SPI3_SCK_PIN  = SCK3  // SCK:  SERCOM7/PAD[1]
-	SPI3_MOSI_PIN = MOSI3 // MOSI: SERCOM7/PAD[3]
-	SPI3_MISO_PIN = MISO3 // MISO: SERCOM7/PAD[2]
-)
-
-// USB CDC identifiers
-const (
-	usb_STRING_PRODUCT      = "Seeed Wio Terminal"
-	usb_STRING_MANUFACTURER = "Seeed"
-)
-
-var (
-	usb_VID uint16 = 0x2886
-	usb_PID uint16 = 0x802D
-)

src/machine/board_wioterminal_baremetal.go

@@ -1,67 +0,0 @@
-// +build sam,atsamd51,wioterminal
-
-package machine
-
-import (
-	"device/sam"
-	"runtime/interrupt"
-)
-
-var (
-	UART1 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM2_USART_INT,
-		SERCOM: 2,
-	}
-
-	// RTL8720D
-	UART2 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM1_USART_INT,
-		SERCOM: 1,
-	}
-)
-
-func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM2_2, UART1.handleInterrupt)
-	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM1_2, UART2.handleInterrupt)
-}
-
-// I2C on the Wio Terminal
-var (
-	I2C0 = I2C{
-		Bus:    sam.SERCOM4_I2CM,
-		SERCOM: 4,
-	}
-
-	I2C1 = I2C{
-		Bus:    sam.SERCOM4_I2CM,
-		SERCOM: 4,
-	}
-)
-
-// SPI on the Wio Terminal
-var (
-	SPI0 = SPI{
-		Bus:    sam.SERCOM5_SPIM,
-		SERCOM: 5,
-	}
-
-	// RTL8720D
-	SPI1 = SPI{
-		Bus:    sam.SERCOM0_SPIM,
-		SERCOM: 0,
-	}
-
-	// SD
-	SPI2 = SPI{
-		Bus:    sam.SERCOM6_SPIM,
-		SERCOM: 6,
-	}
-
-	// LCD
-	SPI3 = SPI{
-		Bus:    sam.SERCOM7_SPIM,
-		SERCOM: 7,
-	}
-)

src/machine/board_xiao.go

@@ -1,126 +0,0 @@
-// +build sam,atsamd21,xiao
-
-package machine
-
-import (
-	"device/sam"
-	"runtime/interrupt"
-)
-
-// used to reset into bootloader
-const RESET_MAGIC_VALUE = 0xf01669ef
-
-// GPIO Pins
-const (
-	D0  = PA02 // can be used for PWM or DAC
-	D1  = PA04 // PWM available
-	D2  = PA10 // PWM available
-	D3  = PA11 // PWM available
-	D4  = PA08 // can be used for PWM or I2C SDA
-	D5  = PA09 // can be used for PWM or I2C SCL
-	D6  = PB08 // can be used for PWM or UART1 TX
-	D7  = PB09 // can be used for PWM or UART1 RX
-	D8  = PA07 // can be used for PWM or SPI SCK
-	D9  = PA05 // can be used for PWM or SPI MISO
-	D10 = PA06 // can be used for PWM or SPI MOSI
-)
-
-// Analog pins
-const (
-	A0  = PA02 // ADC/AIN[0]
-	A1  = PA04 // ADC/AIN[4]
-	A2  = PA10 // ADC/AIN[18]
-	A3  = PA11 // ADC/AIN[19]
-	A4  = PA08 // ADC/AIN[16]
-	A5  = PA09 // ADC/AIN[17]
-	A6  = PB08 // ADC/AIN[2]
-	A7  = PB09 // ADC/AIN[3]
-	A8  = PA07 // ADC/AIN[7]
-	A9  = PA05 // ADC/AIN[6]
-	A10 = PA06 // ADC/AIN[5]
-)
-
-const (
-	LED     = PA17
-	LED_RXL = PA18
-	LED_TXL = PA19
-	LED2    = LED_RXL
-	LED3    = LED_TXL
-)
-
-// UART0 aka USBCDC pins
-const (
-	USBCDC_DM_PIN = PA24
-	USBCDC_DP_PIN = PA25
-)
-
-// UART1 pins
-const (
-	UART_TX_PIN = D6
-	UART_RX_PIN = D7
-)
-
-// UART1 on the Xiao
-var (
-	UART1 = UART{
-		Buffer: NewRingBuffer(),
-		Bus:    sam.SERCOM4_USART,
-		SERCOM: 4,
-	}
-)
-
-func init() {
-	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM4, UART1.handleInterrupt)
-}
-
-// I2C pins
-const (
-	SDA_PIN = PA08 // SDA: SERCOM2/PAD[0]
-	SCL_PIN = PA09 // SCL: SERCOM2/PAD[1]
-)
-
-// I2C on the Xiao
-var (
-	I2C0 = I2C{
-		Bus:    sam.SERCOM2_I2CM,
-		SERCOM: 2,
-	}
-)
-
-// SPI pins
-const (
-	SPI0_SCK_PIN  = PA07 // SCK: SERCOM0/PAD[3]
-	SPI0_MOSI_PIN = PA06 // MOSI: SERCOM0/PAD[2]
-	SPI0_MISO_PIN = PA05 // MISO: SERCOM0/PAD[1]
-)
-
-// SPI on the Xiao
-var (
-	SPI0 = SPI{
-		Bus:    sam.SERCOM0_SPI,
-		SERCOM: 0,
-	}
-)
-
-// I2S pins
-const (
-	I2S_SCK_PIN = PA10
-	I2S_SD_PIN  = PA08
-	I2S_WS_PIN  = NoPin // TODO: figure out what this is on Xiao
-)
-
-// I2S on the Xiao
-var (
-	I2S0 = I2S{Bus: sam.I2S}
-)
-
-// USB CDC identifiers
-const (
-	usb_STRING_PRODUCT      = "Seeed XIAO M0"
-	usb_STRING_MANUFACTURER = "Seeed"
-)
-
-var (
-	usb_VID uint16 = 0x2886
-	usb_PID uint16 = 0x802F
-)

src/machine/machine.go

@@ -3,11 +3,10 @@ package machine
 import "errors"
 
 var (
-	ErrInvalidInputPin    = errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin   = errors.New("machine: invalid output pin")
-	ErrInvalidClockPin    = errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin     = errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel = errors.New("machine: no channel available for pin interrupt")
+	ErrInvalidInputPin  = errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin = errors.New("machine: invalid output pin")
+	ErrInvalidClockPin  = errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin   = errors.New("machine: invalid data pin")
 )
 
 type PinConfig struct {

src/machine/machine_atmega.go

@@ -7,6 +7,72 @@ import (
 	"runtime/interrupt"
 )
 
+// InitPWM initializes the registers needed for PWM.
+func InitPWM() {
+	// use waveform generation
+	avr.TCCR0A.SetBits(avr.TCCR0A_WGM00)
+
+	// set timer 0 prescale factor to 64
+	avr.TCCR0B.SetBits(avr.TCCR0B_CS01 | avr.TCCR0B_CS00)
+
+	// set timer 1 prescale factor to 64
+	avr.TCCR1B.SetBits(avr.TCCR1B_CS11)
+
+	// put timer 1 in 8-bit phase correct pwm mode
+	avr.TCCR1A.SetBits(avr.TCCR1A_WGM10)
+
+	// set timer 2 prescale factor to 64
+	avr.TCCR2B.SetBits(avr.TCCR2B_CS22)
+
+	// configure timer 2 for phase correct pwm (8-bit)
+	avr.TCCR2A.SetBits(avr.TCCR2A_WGM20)
+}
+
+// Configure configures a PWM pin for output.
+func (pwm PWM) Configure() {
+	if pwm.Pin < 8 {
+		avr.DDRD.SetBits(1 << uint8(pwm.Pin))
+	} else {
+		avr.DDRB.SetBits(1 << uint8(pwm.Pin-8))
+	}
+}
+
+// Set turns on the duty cycle for a PWM pin using the provided value. On the AVR this is normally a
+// 8-bit value ranging from 0 to 255.
+func (pwm PWM) Set(value uint16) {
+	value8 := uint8(value >> 8)
+	switch pwm.Pin {
+	case 3:
+		// connect pwm to pin on timer 2, channel B
+		avr.TCCR2A.SetBits(avr.TCCR2A_COM2B1)
+		avr.OCR2B.Set(value8) // set pwm duty
+	case 5:
+		// connect pwm to pin on timer 0, channel B
+		avr.TCCR0A.SetBits(avr.TCCR0A_COM0B1)
+		avr.OCR0B.Set(value8) // set pwm duty
+	case 6:
+		// connect pwm to pin on timer 0, channel A
+		avr.TCCR0A.SetBits(avr.TCCR0A_COM0A1)
+		avr.OCR0A.Set(value8) // set pwm duty
+	case 9:
+		// connect pwm to pin on timer 1, channel A
+		avr.TCCR1A.SetBits(avr.TCCR1A_COM1A1)
+		// this is a 16-bit value, but we only currently allow the low order bits to be set
+		avr.OCR1AL.Set(value8) // set pwm duty
+	case 10:
+		// connect pwm to pin on timer 1, channel B
+		avr.TCCR1A.SetBits(avr.TCCR1A_COM1B1)
+		// this is a 16-bit value, but we only currently allow the low order bits to be set
+		avr.OCR1BL.Set(value8) // set pwm duty
+	case 11:
+		// connect pwm to pin on timer 2, channel A
+		avr.TCCR2A.SetBits(avr.TCCR2A_COM2A1)
+		avr.OCR2A.Set(value8) // set pwm duty
+	default:
+		panic("Invalid PWM pin")
+	}
+}
+
 // I2CConfig is used to store config info for I2C.
 type I2CConfig struct {
 	Frequency uint32

src/machine/machine_atmega1284p.go

@@ -14,58 +14,12 @@ func CPUFrequency() uint32 {
 	return 20000000
 }
 
-const (
-	portA Pin = iota * 8
-	portB
-	portC
-	portD
-)
-
-const (
-	PA0 = portA + 0
-	PA1 = portA + 1
-	PA2 = portA + 2
-	PA3 = portA + 3
-	PA4 = portA + 4
-	PA5 = portA + 5
-	PA6 = portA + 6
-	PA7 = portA + 7
-	PB0 = portB + 0
-	PB1 = portB + 1
-	PB2 = portB + 2
-	PB3 = portB + 3
-	PB4 = portB + 4
-	PB5 = portB + 5
-	PB6 = portB + 6
-	PB7 = portB + 7
-	PC0 = portC + 0
-	PC1 = portC + 1
-	PC2 = portC + 2
-	PC3 = portC + 3
-	PC4 = portC + 4
-	PC5 = portC + 5
-	PC6 = portC + 6
-	PC7 = portC + 7
-	PD0 = portD + 0
-	PD1 = portD + 1
-	PD2 = portD + 2
-	PD3 = portD + 3
-	PD4 = portD + 4
-	PD5 = portD + 5
-	PD6 = portD + 6
-	PD7 = portD + 7
-)
-
-// getPortMask returns the PORTx register and mask for the pin.
 func (p Pin) getPortMask() (*volatile.Register8, uint8) {
-	switch {
-	case p >= PA0 && p <= PA7:
-		return avr.PORTA, 1 << uint8(p-portA)
-	case p >= PB0 && p <= PB7:
-		return avr.PORTB, 1 << uint8(p-portB)
-	case p >= PC0 && p <= PC7:
-		return avr.PORTC, 1 << uint8(p-portC)
-	default:
-		return avr.PORTD, 1 << uint8(p-portD)
+	if p < 8 {
+		return avr.PORTD, 1 << uint8(p)
+	} else if p < 14 {
+		return avr.PORTB, 1 << uint8(p-8)
+	} else {
+		return avr.PORTC, 1 << uint8(p-14)
 	}
 }

src/machine/machine_atmega2560.go

@@ -96,32 +96,53 @@ const (
 	PL7 = portE + 7
 )
 
-// getPortMask returns the PORTx register and mask for the pin.
-func (p Pin) getPortMask() (*volatile.Register8, uint8) {
-	switch {
-	case p >= PA0 && p <= PA7:
-		return avr.PORTA, 1 << uint8(p-portA)
-	case p >= PB0 && p <= PB7:
-		return avr.PORTB, 1 << uint8(p-portB)
-	case p >= PC0 && p <= PC7:
-		return avr.PORTC, 1 << uint8(p-portC)
-	case p >= PD0 && p <= PD7:
-		return avr.PORTD, 1 << uint8(p-portD)
-	case p >= PE0 && p <= PE6:
-		return avr.PORTE, 1 << uint8(p-portE)
-	case p >= PF0 && p <= PF7:
-		return avr.PORTF, 1 << uint8(p-portF)
-	case p >= PG0 && p <= PG5:
-		return avr.PORTG, 1 << uint8(p-portG)
-	case p >= PH0 && p <= PH6:
-		return avr.PORTH, 1 << uint8(p-portH)
-	case p >= PJ0 && p <= PJ1:
-		return avr.PORTJ, 1 << uint8(p-portJ)
-	case p >= PK0 && p <= PK7:
-		return avr.PORTK, 1 << uint8(p-portK)
-	case p >= PL0 && p <= PL7:
-		return avr.PORTL, 1 << uint8(p-portL)
-	default:
-		return avr.PORTA, 255
+// Configure sets the pin to input or output.
+func (p Pin) Configure(config PinConfig) {
+	register, _, mask := p.getRegisterPortMask()
+	if config.Mode == PinOutput { // set output bit
+		register.SetBits(mask)
+	} else { // configure input: clear output bit
+		register.ClearBits(mask)
+	}
+}
+
+// Get returns the current value of a GPIO pin.
+func (p Pin) Get() bool {
+	_, port, mask := p.getRegisterPortMask()
+	return (port.Get() & mask) > 0
+}
+
+func (p Pin) getPortMask() (*volatile.Register8, uint8) {
+	_, port, mask := p.getRegisterPortMask()
+	return port, mask
+}
+
+// getRegisterPortMask returns the register, port, and mask for the pin
+func (p Pin) getRegisterPortMask() (*volatile.Register8, *volatile.Register8, uint8) {
+	switch {
+	case p >= PA0 && p <= PA7:
+		return avr.DDRA, avr.PORTA, 1 << uint8(p-portA)
+	case p >= PB0 && p <= PB7:
+		return avr.DDRB, avr.PORTB, 1 << uint8(p-portB)
+	case p >= PC0 && p <= PC7:
+		return avr.DDRC, avr.PORTC, 1 << uint8(p-portC)
+	case p >= PD0 && p <= PD7:
+		return avr.DDRD, avr.PORTD, 1 << uint8(p-portD)
+	case p >= PE0 && p <= PE6:
+		return avr.DDRE, avr.PORTE, 1 << uint8(p-portE)
+	case p >= PF0 && p <= PF7:
+		return avr.DDRF, avr.PORTF, 1 << uint8(p-portF)
+	case p >= PG0 && p <= PG5:
+		return avr.DDRG, avr.PORTG, 1 << uint8(p-portG)
+	case p >= PH0 && p <= PH6:
+		return avr.DDRH, avr.PORTH, 1 << uint8(p-portH)
+	case p >= PJ0 && p <= PJ1:
+		return avr.DDRJ, avr.PORTJ, 1 << uint8(p-portJ)
+	case p >= PK0 && p <= PK7:
+		return avr.DDRK, avr.PORTK, 1 << uint8(p-portK)
+	case p >= PL0 && p <= PL7:
+		return avr.DDRL, avr.PORTL, 1 << uint8(p-portL)
+	default:
+		return avr.DDRB, avr.PORTA, 255
 	}
 }

src/machine/machine_atmega328p.go

@@ -9,82 +9,47 @@ import (
 
 const irq_USART0_RX = avr.IRQ_USART_RX
 
-// getPortMask returns the PORTx register and mask for the pin.
+// Configure sets the pin to input or output.
+func (p Pin) Configure(config PinConfig) {
+	if config.Mode == PinOutput { // set output bit
+		if p < 8 {
+			avr.DDRD.SetBits(1 << uint8(p))
+		} else if p < 14 {
+			avr.DDRB.SetBits(1 << uint8(p-8))
+		} else {
+			avr.DDRC.SetBits(1 << uint8(p-14))
+		}
+	} else { // configure input: clear output bit
+		if p < 8 {
+			avr.DDRD.ClearBits(1 << uint8(p))
+		} else if p < 14 {
+			avr.DDRB.ClearBits(1 << uint8(p-8))
+		} else {
+			avr.DDRC.ClearBits(1 << uint8(p-14))
+		}
+	}
+}
+
+// Get returns the current value of a GPIO pin.
+func (p Pin) Get() bool {
+	if p < 8 {
+		val := avr.PIND.Get() & (1 << uint8(p))
+		return (val > 0)
+	} else if p < 14 {
+		val := avr.PINB.Get() & (1 << uint8(p-8))
+		return (val > 0)
+	} else {
+		val := avr.PINC.Get() & (1 << uint8(p-14))
+		return (val > 0)
+	}
+}
+
 func (p Pin) getPortMask() (*volatile.Register8, uint8) {
-	switch {
-	case p >= PB0 && p <= PB7: // port B
-		return avr.PORTB, 1 << uint8(p-portB)
-	case p >= PC0 && p <= PC7: // port C
-		return avr.PORTC, 1 << uint8(p-portC)
-	default: // port D
-		return avr.PORTD, 1 << uint8(p-portD)
-	}
-}
-
-// InitPWM initializes the registers needed for PWM.
-func InitPWM() {
-	// use waveform generation
-	avr.TCCR0A.SetBits(avr.TCCR0A_WGM00)
-
-	// set timer 0 prescale factor to 64
-	avr.TCCR0B.SetBits(avr.TCCR0B_CS01 | avr.TCCR0B_CS00)
-
-	// set timer 1 prescale factor to 64
-	avr.TCCR1B.SetBits(avr.TCCR1B_CS11)
-
-	// put timer 1 in 8-bit phase correct pwm mode
-	avr.TCCR1A.SetBits(avr.TCCR1A_WGM10)
-
-	// set timer 2 prescale factor to 64
-	avr.TCCR2B.SetBits(avr.TCCR2B_CS22)
-
-	// configure timer 2 for phase correct pwm (8-bit)
-	avr.TCCR2A.SetBits(avr.TCCR2A_WGM20)
-}
-
-// Configure configures a PWM pin for output.
-func (pwm PWM) Configure() error {
-	switch pwm.Pin / 8 {
-	case 0: // port B
-		avr.DDRB.SetBits(1 << uint8(pwm.Pin))
-	case 2: // port D
-		avr.DDRD.SetBits(1 << uint8(pwm.Pin-16))
-	}
-	return nil
-}
-
-// Set turns on the duty cycle for a PWM pin using the provided value. On the AVR this is normally a
-// 8-bit value ranging from 0 to 255.
-func (pwm PWM) Set(value uint16) {
-	value8 := uint8(value >> 8)
-	switch pwm.Pin {
-	case PD3:
-		// connect pwm to pin on timer 2, channel B
-		avr.TCCR2A.SetBits(avr.TCCR2A_COM2B1)
-		avr.OCR2B.Set(value8) // set pwm duty
-	case PD5:
-		// connect pwm to pin on timer 0, channel B
-		avr.TCCR0A.SetBits(avr.TCCR0A_COM0B1)
-		avr.OCR0B.Set(value8) // set pwm duty
-	case PD6:
-		// connect pwm to pin on timer 0, channel A
-		avr.TCCR0A.SetBits(avr.TCCR0A_COM0A1)
-		avr.OCR0A.Set(value8) // set pwm duty
-	case PB1:
-		// connect pwm to pin on timer 1, channel A
-		avr.TCCR1A.SetBits(avr.TCCR1A_COM1A1)
-		// this is a 16-bit value, but we only currently allow the low order bits to be set
-		avr.OCR1AL.Set(value8) // set pwm duty
-	case PB2:
-		// connect pwm to pin on timer 1, channel B
-		avr.TCCR1A.SetBits(avr.TCCR1A_COM1B1)
-		// this is a 16-bit value, but we only currently allow the low order bits to be set
-		avr.OCR1BL.Set(value8) // set pwm duty
-	case PB3:
-		// connect pwm to pin on timer 2, channel A
-		avr.TCCR2A.SetBits(avr.TCCR2A_COM2A1)
-		avr.OCR2A.Set(value8) // set pwm duty
-	default:
-		panic("Invalid PWM pin")
+	if p < 8 {
+		return avr.PORTD, 1 << uint8(p)
+	} else if p < 14 {
+		return avr.PORTB, 1 << uint8(p-8)
+	} else {
+		return avr.PORTC, 1 << uint8(p-14)
 	}
 }

src/machine/machine_atsamd21.go

@@ -33,26 +33,6 @@ const (
 	PinInputPulldown PinMode = 12
 )
 
-type PinChange uint8
-
-// Pin change interrupt constants for SetInterrupt.
-const (
-	PinRising  PinChange = sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling PinChange = sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle  PinChange = sam.EIC_CONFIG_SENSE0_BOTH
-)
-
-// Callbacks to be called for pins configured with SetInterrupt. Unfortunately,
-// we also need to keep track of which interrupt channel is used by which pin,
-// as the only alternative would be iterating through all pins.
-//
-// We're using the magic constant 16 here because the SAM D21 has 16 interrupt
-// channels configurable for pins.
-var (
-	interruptPins [16]Pin // warning: the value is invalid when pinCallbacks[i] is not set!
-	pinCallbacks  [16]func(Pin)
-)
-
 const (
 	pinPadMapSERCOM0Pad0 byte = (0x10 << 1) | 0x00
 	pinPadMapSERCOM1Pad0 byte = (0x20 << 1) | 0x00
@@ -164,114 +144,6 @@ func findPinPadMapping(sercom uint8, pin Pin) (pinMode PinMode, pad uint32, ok b
 	return
 }
 
-// SetInterrupt sets an interrupt to be executed when a particular pin changes
-// state.
-//
-// This call will replace a previously set callback on this pin. You can pass a
-// nil func to unset the pin change interrupt. If you do so, the change
-// parameter is ignored and can be set to any value (such as 0).
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error {
-	// Most pins follow a common pattern where the EXTINT value is the pin
-	// number modulo 16. However, there are a few exceptions, as you can see
-	// below.
-	extint := uint8(0)
-	switch p {
-	case PA08:
-		// Connected to NMI. This is not currently supported.
-		return ErrInvalidInputPin
-	case PA24:
-		extint = 12
-	case PA25:
-		extint = 13
-	case PA27:
-		extint = 15
-	case PA28:
-		extint = 8
-	case PA30:
-		extint = 10
-	case PA31:
-		extint = 11
-	default:
-		// All other pins follow a normal pattern.
-		extint = uint8(p) % 16
-	}
-
-	if callback == nil {
-		// Disable this pin interrupt (if it was enabled).
-		sam.EIC.INTENCLR.Set(1 << extint)
-		if pinCallbacks[extint] != nil {
-			pinCallbacks[extint] = nil
-		}
-		return nil
-	}
-
-	if pinCallbacks[extint] != nil {
-		// The pin was already configured.
-		// To properly re-configure a pin, unset it first and set a new
-		// configuration.
-		return ErrNoPinChangeChannel
-	}
-	pinCallbacks[extint] = callback
-	interruptPins[extint] = p
-
-	if sam.EIC.CTRL.Get() == 0 {
-		// EIC peripheral has not yet been initialized. Initialize it now.
-
-		// The EIC needs two clocks: CLK_EIC_APB and GCLK_EIC. CLK_EIC_APB is
-		// enabled by default, so doesn't have to be re-enabled. The other is
-		// required for detecting edges and must be enabled manually.
-		sam.GCLK.CLKCTRL.Set(sam.GCLK_CLKCTRL_ID_EIC<<sam.GCLK_CLKCTRL_ID_Pos |
-			sam.GCLK_CLKCTRL_GEN_GCLK0<<sam.GCLK_CLKCTRL_GEN_Pos |
-			sam.GCLK_CLKCTRL_CLKEN)
-
-		// should not be necessary (CLKCTRL is not synchronized)
-		for sam.GCLK.STATUS.HasBits(sam.GCLK_STATUS_SYNCBUSY) {
-		}
-
-		sam.EIC.CTRL.Set(sam.EIC_CTRL_ENABLE)
-		for sam.EIC.STATUS.HasBits(sam.EIC_STATUS_SYNCBUSY) {
-		}
-	}
-
-	// Configure this pin. Set the 4 bits of the EIC.CONFIGx register to the
-	// sense value (filter bit set to 0, sense bits set to the change value).
-	addr := &sam.EIC.CONFIG0
-	if extint >= 8 {
-		addr = &sam.EIC.CONFIG1
-	}
-	pos := (extint % 8) * 4 // bit position in register
-	addr.Set((addr.Get() &^ (0xf << pos)) | uint32(change)<<pos)
-
-	// Enable external interrupt for this pin.
-	sam.EIC.INTENSET.Set(1 << extint)
-
-	// Set the PMUXEN flag, while keeping the INEN and PULLEN flags (if they
-	// were set before). This avoids clearing the pin pull mode while
-	// configuring the pin interrupt.
-	p.setPinCfg(sam.PORT_PINCFG0_PMUXEN | (p.getPinCfg() & (sam.PORT_PINCFG0_INEN | sam.PORT_PINCFG0_PULLEN)))
-	if p&1 > 0 {
-		// odd pin, so save the even pins
-		val := p.getPMux() & sam.PORT_PMUX0_PMUXE_Msk
-		p.setPMux(val | (sam.PORT_PMUX0_PMUXO_A << sam.PORT_PMUX0_PMUXO_Pos))
-	} else {
-		// even pin, so save the odd pins
-		val := p.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
-		p.setPMux(val | (sam.PORT_PMUX0_PMUXE_A << sam.PORT_PMUX0_PMUXE_Pos))
-	}
-
-	interrupt.New(sam.IRQ_EIC, func(interrupt.Interrupt) {
-		flags := sam.EIC.INTFLAG.Get()
-		sam.EIC.INTFLAG.Set(flags)      // clear interrupt
-		for i := uint(0); i < 16; i++ { // there are 16 channels
-			if flags&(1<<i) != 0 {
-				pinCallbacks[i](interruptPins[i])
-			}
-		}
-	}).Enable()
-
-	return nil
-}
-
 // InitADC initializes the ADC.
 func InitADC() {
 	// ADC Bias Calibration
@@ -388,16 +260,6 @@ func (a ADC) getADCChannel() uint8 {
 	switch a.Pin {
 	case PA02:
 		return 0
-	case PA03:
-		return 1
-	case PB04:
-		return 12
-	case PB05:
-		return 13
-	case PB06:
-		return 14
-	case PB07:
-		return 15
 	case PB08:
 		return 2
 	case PB09:
@@ -410,22 +272,14 @@ func (a ADC) getADCChannel() uint8 {
 		return 6
 	case PA07:
 		return 7
-	case PA08:
-		return 16
-	case PA09:
-		return 17
-	case PA10:
-		return 18
-	case PA11:
-		return 19
-	case PB00:
-		return 8
-	case PB01:
-		return 9
 	case PB02:
 		return 10
 	case PB03:
 		return 11
+	case PA09:
+		return 17
+	case PA11:
+		return 19
 	default:
 		return 0
 	}
@@ -1236,12 +1090,9 @@ func InitPWM() {
 }
 
 // Configure configures a PWM pin for output.
-func (pwm PWM) Configure() error {
+func (pwm PWM) Configure() {
 	// figure out which TCCX timer for this pin
 	timer := pwm.getTimer()
-	if timer == nil {
-		return ErrInvalidOutputPin
-	}
 
 	// disable timer
 	timer.CTRLA.ClearBits(sam.TCC_CTRLA_ENABLE)
@@ -1288,19 +1139,12 @@ func (pwm PWM) Configure() error {
 		val := pwm.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
 		pwm.setPMux(val | uint8(pwmConfig<<sam.PORT_PMUX0_PMUXE_Pos))
 	}
-
-	return nil
 }
 
 // Set turns on the duty cycle for a PWM pin using the provided value.
 func (pwm PWM) Set(value uint16) {
 	// figure out which TCCX timer for this pin
 	timer := pwm.getTimer()
-	if timer == nil {
-		// The Configure call above cannot have succeeded, so simply ignore this
-		// error.
-		return
-	}
 
 	// disable output
 	timer.CTRLA.ClearBits(sam.TCC_CTRLA_ENABLE)
@@ -1310,7 +1154,7 @@ func (pwm PWM) Set(value uint16) {
 	}
 
 	// Set PWM signal to output duty cycle
-	pwm.setChannel(timer, uint32(value))
+	pwm.setChannel(uint32(value))
 
 	// Wait for synchronization on all channels
 	for timer.SYNCBUSY.HasBits(sam.TCC_SYNCBUSY_CC0 |
@@ -1379,32 +1223,32 @@ func (pwm PWM) getTimer() *sam.TCC_Type {
 }
 
 // setChannel sets the value for the correct channel for PWM on this pin
-func (pwm PWM) setChannel(timer *sam.TCC_Type, val uint32) {
+func (pwm PWM) setChannel(val uint32) {
 	switch pwm.Pin {
 	case 6:
-		timer.CC0.Set(val)
+		pwm.getTimer().CC0.Set(val)
 	case 7:
-		timer.CC1.Set(val)
+		pwm.getTimer().CC1.Set(val)
 	case 8:
-		timer.CC0.Set(val)
+		pwm.getTimer().CC0.Set(val)
 	case 9:
-		timer.CC1.Set(val)
+		pwm.getTimer().CC1.Set(val)
 	case 14:
-		timer.CC0.Set(val)
+		pwm.getTimer().CC0.Set(val)
 	case 15:
-		timer.CC1.Set(val)
+		pwm.getTimer().CC1.Set(val)
 	case 16:
-		timer.CC2.Set(val)
+		pwm.getTimer().CC2.Set(val)
 	case 17:
-		timer.CC3.Set(val)
+		pwm.getTimer().CC3.Set(val)
 	case 18:
-		timer.CC2.Set(val)
+		pwm.getTimer().CC2.Set(val)
 	case 19:
-		timer.CC3.Set(val)
+		pwm.getTimer().CC3.Set(val)
 	case 20:
-		timer.CC2.Set(val)
+		pwm.getTimer().CC2.Set(val)
 	case 21:
-		timer.CC3.Set(val)
+		pwm.getTimer().CC3.Set(val)
 	default:
 		return // not supported on this pin
 	}

src/machine/machine_atsamd51.go

@@ -44,26 +44,6 @@ const (
 	PinInputPulldown PinMode = 18
 )
 
-type PinChange uint8
-
-// Pin change interrupt constants for SetInterrupt.
-const (
-	PinRising  PinChange = sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling PinChange = sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle  PinChange = sam.EIC_CONFIG_SENSE0_BOTH
-)
-
-// Callbacks to be called for pins configured with SetInterrupt. Unfortunately,
-// we also need to keep track of which interrupt channel is used by which pin,
-// as the only alternative would be iterating through all pins.
-//
-// We're using the magic constant 16 here because the SAM D21 has 16 interrupt
-// channels configurable for pins.
-var (
-	interruptPins [16]Pin // warning: the value is invalid when pinCallbacks[i] is not set!
-	pinCallbacks  [16]func(Pin)
-)
-
 // Hardware pins
 const (
 	PA00 Pin = 0
@@ -130,70 +110,6 @@ const (
 	PB29 Pin = 61
 	PB30 Pin = 62
 	PB31 Pin = 63
-	PC00 Pin = 64
-	PC01 Pin = 65
-	PC02 Pin = 66
-	PC03 Pin = 67
-	PC04 Pin = 68
-	PC05 Pin = 69
-	PC06 Pin = 70
-	PC07 Pin = 71
-	PC08 Pin = 72
-	PC09 Pin = 73
-	PC10 Pin = 74
-	PC11 Pin = 75
-	PC12 Pin = 76
-	PC13 Pin = 77
-	PC14 Pin = 78
-	PC15 Pin = 79
-	PC16 Pin = 80
-	PC17 Pin = 81
-	PC18 Pin = 82
-	PC19 Pin = 83
-	PC20 Pin = 84
-	PC21 Pin = 85
-	PC22 Pin = 86
-	PC23 Pin = 87
-	PC24 Pin = 88
-	PC25 Pin = 89
-	PC26 Pin = 90
-	PC27 Pin = 91
-	PC28 Pin = 92
-	PC29 Pin = 93
-	PC30 Pin = 94
-	PC31 Pin = 95
-	PD00 Pin = 96
-	PD01 Pin = 97
-	PD02 Pin = 98
-	PD03 Pin = 99
-	PD04 Pin = 100
-	PD05 Pin = 101
-	PD06 Pin = 102
-	PD07 Pin = 103
-	PD08 Pin = 104
-	PD09 Pin = 105
-	PD10 Pin = 106
-	PD11 Pin = 107
-	PD12 Pin = 108
-	PD13 Pin = 109
-	PD14 Pin = 110
-	PD15 Pin = 111
-	PD16 Pin = 112
-	PD17 Pin = 113
-	PD18 Pin = 114
-	PD19 Pin = 115
-	PD20 Pin = 116
-	PD21 Pin = 117
-	PD22 Pin = 118
-	PD23 Pin = 119
-	PD24 Pin = 120
-	PD25 Pin = 121
-	PD26 Pin = 122
-	PD27 Pin = 123
-	PD28 Pin = 124
-	PD29 Pin = 125
-	PD30 Pin = 126
-	PD31 Pin = 127
 )
 
 const (
@@ -264,7 +180,7 @@ const (
 // easy to check whether a nibble is set at all.
 //
 // Datasheet: http://ww1.microchip.com/downloads/en/DeviceDoc/60001507E.pdf
-var pinPadMapping = [64]uint16{
+var pinPadMapping = [32]uint16{
 	// page 32
 	PA00 / 2: 0 | pinPadMapSERCOM1AltPad0,
 
@@ -272,28 +188,28 @@ var pinPadMapping = [64]uint16{
 	PB08 / 2: 0 | pinPadMapSERCOM4AltPad0,
 	PA04 / 2: 0 | pinPadMapSERCOM0AltPad0,
 	PA06 / 2: 0 | pinPadMapSERCOM0AltPad2,
-	PC04 / 2: pinPadMapSERCOM6Pad0 | 0,
-	PC06 / 2: pinPadMapSERCOM6Pad2 | 0,
+	//PC04 / 2: pinPadMapSERCOM6Pad0 | 0,
+	//PC06 / 2: pinPadMapSERCOM6Pad2 | 0,
 	PA08 / 2: pinPadMapSERCOM0Pad0 | pinPadMapSERCOM2AltPad1,
 	PA10 / 2: pinPadMapSERCOM0Pad2 | pinPadMapSERCOM2AltPad2,
 	PB10 / 2: 0 | pinPadMapSERCOM4AltPad2,
 	PB12 / 2: pinPadMapSERCOM4Pad0 | 0,
 	PB14 / 2: pinPadMapSERCOM4Pad2 | 0,
-	PD08 / 2: pinPadMapSERCOM7Pad0 | pinPadMapSERCOM6AltPad1,
-	PD10 / 2: pinPadMapSERCOM7Pad2 | pinPadMapSERCOM6AltPad2,
-	PC10 / 2: pinPadMapSERCOM6Pad2 | pinPadMapSERCOM7AltPad2,
+	//PD08 / 2: pinPadMapSERCOM7Pad0 | pinPadMapSERCOM6AltPad1,
+	//PD10 / 2: pinPadMapSERCOM7Pad2 | pinPadMapSERCOM6AltPad2,
+	//PC10 / 2: pinPadMapSERCOM6Pad2 | pinPadMapSERCOM7AltPad2,
 
 	// page 34
-	PC12 / 2: pinPadMapSERCOM7Pad0 | pinPadMapSERCOM6AltPad1,
-	PC14 / 2: pinPadMapSERCOM7Pad2 | pinPadMapSERCOM6AltPad2,
+	//PC12 / 2: pinPadMapSERCOM7Pad0 | pinPadMapSERCOM6AltPad1,
+	//PC14 / 2: pinPadMapSERCOM7Pad2 | pinPadMapSERCOM6AltPad2,
 	PA12 / 2: pinPadMapSERCOM2Pad0 | pinPadMapSERCOM4AltPad1,
 	PA14 / 2: pinPadMapSERCOM2Pad2 | pinPadMapSERCOM4AltPad2,
 	PA16 / 2: pinPadMapSERCOM1Pad0 | pinPadMapSERCOM3AltPad1,
 	PA18 / 2: pinPadMapSERCOM1Pad2 | pinPadMapSERCOM3AltPad2,
-	PC16 / 2: pinPadMapSERCOM6Pad0 | pinPadMapSERCOM0AltPad1,
-	PC18 / 2: pinPadMapSERCOM6Pad2 | pinPadMapSERCOM0AltPad2,
-	PC22 / 2: pinPadMapSERCOM1Pad0 | pinPadMapSERCOM3AltPad1,
-	PD20 / 2: pinPadMapSERCOM1Pad2 | pinPadMapSERCOM3AltPad2,
+	//PC16 / 2: pinPadMapSERCOM6Pad0 | pinPadMapSERCOM0AltPad1,
+	//PC18 / 2: pinPadMapSERCOM6Pad2 | pinPadMapSERCOM0AltPad2,
+	//PC22 / 2: pinPadMapSERCOM1Pad0 | pinPadMapSERCOM3AltPad1,
+	//PD20 / 2: pinPadMapSERCOM1Pad2 | pinPadMapSERCOM3AltPad2,
 	PB16 / 2: pinPadMapSERCOM5Pad0 | 0,
 	PB18 / 2: pinPadMapSERCOM5Pad2 | pinPadMapSERCOM7AltPad2,
 
@@ -306,7 +222,7 @@ var pinPadMapping = [64]uint16{
 	PB24 / 2: pinPadMapSERCOM0Pad0 | pinPadMapSERCOM2AltPad1,
 	PB26 / 2: pinPadMapSERCOM2Pad0 | pinPadMapSERCOM4AltPad1,
 	PB28 / 2: pinPadMapSERCOM2Pad2 | pinPadMapSERCOM4AltPad2,
-	PC24 / 2: pinPadMapSERCOM0Pad2 | pinPadMapSERCOM2AltPad2,
+	//PC24 / 2: pinPadMapSERCOM0Pad2 | pinPadMapSERCOM2AltPad2,
 	//PC26 / 2: pinPadMapSERCOM1Pad1 | 0, // note: PC26 doesn't support SERCOM, but PC27 does
 	//PC28 / 2: pinPadMapSERCOM1Pad1 | 0, // note: PC29 doesn't exist in the datasheet?
 	PA30 / 2: 0 | pinPadMapSERCOM1AltPad2,
@@ -352,162 +268,6 @@ func findPinPadMapping(sercom uint8, pin Pin) (pinMode PinMode, pad uint32, ok b
 	return
 }
 
-// SetInterrupt sets an interrupt to be executed when a particular pin changes
-// state.
-//
-// This call will replace a previously set callback on this pin. You can pass a
-// nil func to unset the pin change interrupt. If you do so, the change
-// parameter is ignored and can be set to any value (such as 0).
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error {
-	// Most pins follow a common pattern where the EXTINT value is the pin
-	// number modulo 16. However, there are a few exceptions, as you can see
-	// below.
-	extint := uint8(0)
-
-	switch p {
-	case PA08:
-		// Connected to NMI. This is not currently supported.
-		return ErrInvalidInputPin
-	case PB26:
-		extint = 12
-	case PB27:
-		extint = 13
-	case PB28:
-		extint = 14
-	case PB29:
-		extint = 15
-	case PC07:
-		extint = 9
-	case PD08:
-		extint = 3
-	case PD09:
-		extint = 4
-	case PD10:
-		extint = 5
-	case PD11:
-		extint = 6
-	case PD12:
-		extint = 7
-	case PD20:
-		extint = 10
-	case PD21:
-		extint = 11
-	default:
-		// All other pins follow a normal pattern.
-		extint = uint8(p) % 16
-	}
-
-	if callback == nil {
-		// Disable this pin interrupt (if it was enabled).
-		sam.EIC.INTENCLR.Set(1 << extint)
-		if pinCallbacks[extint] != nil {
-			pinCallbacks[extint] = nil
-		}
-		return nil
-	}
-
-	if pinCallbacks[extint] != nil {
-		// The pin was already configured.
-		// To properly re-configure a pin, unset it first and set a new
-		// configuration.
-		return ErrNoPinChangeChannel
-	}
-	pinCallbacks[extint] = callback
-	interruptPins[extint] = p
-
-	if !sam.EIC.CTRLA.HasBits(sam.EIC_CTRLA_ENABLE) {
-		// EIC peripheral has not yet been initialized. Initialize it now.
-
-		// The EIC needs two clocks: CLK_EIC_APB and GCLK_EIC. CLK_EIC_APB is
-		// enabled by default, so doesn't have to be re-enabled. The other is
-		// required for detecting edges and must be enabled manually.
-		sam.GCLK.PCHCTRL[4].Set((sam.GCLK_PCHCTRL_GEN_GCLK0 << sam.GCLK_PCHCTRL_GEN_Pos) | sam.GCLK_PCHCTRL_CHEN)
-
-		// should not be necessary (CLKCTRL is not synchronized)
-		for sam.GCLK.SYNCBUSY.HasBits(sam.GCLK_SYNCBUSY_GENCTRL_GCLK0 << sam.GCLK_SYNCBUSY_GENCTRL_Pos) {
-		}
-	}
-
-	// CONFIG register is enable-protected, so disable EIC.
-	sam.EIC.CTRLA.ClearBits(sam.EIC_CTRLA_ENABLE)
-
-	// Configure this pin. Set the 4 bits of the EIC.CONFIGx register to the
-	// sense value (filter bit set to 0, sense bits set to the change value).
-	addr := &sam.EIC.CONFIG[0]
-	if extint >= 8 {
-		addr = &sam.EIC.CONFIG[1]
-	}
-	pos := (extint % 8) * 4 // bit position in register
-	addr.Set((addr.Get() &^ (0xf << pos)) | uint32(change)<<pos)
-
-	// Enable external interrupt for this pin.
-	sam.EIC.INTENSET.Set(1 << extint)
-
-	sam.EIC.CTRLA.Set(sam.EIC_CTRLA_ENABLE)
-	for sam.EIC.SYNCBUSY.HasBits(sam.EIC_SYNCBUSY_ENABLE) {
-	}
-
-	// Set the PMUXEN flag, while keeping the INEN and PULLEN flags (if they
-	// were set before). This avoids clearing the pin pull mode while
-	// configuring the pin interrupt.
-	p.setPinCfg(sam.PORT_GROUP_PINCFG_PMUXEN | (p.getPinCfg() & (sam.PORT_GROUP_PINCFG_INEN | sam.PORT_GROUP_PINCFG_PULLEN)))
-	if p&1 > 0 {
-		// odd pin, so save the even pins
-		val := p.getPMux() & sam.PORT_GROUP_PMUX_PMUXE_Msk
-		p.setPMux(val | (0 << sam.PORT_GROUP_PMUX_PMUXO_Pos))
-	} else {
-		// even pin, so save the odd pins
-		val := p.getPMux() & sam.PORT_GROUP_PMUX_PMUXO_Msk
-		p.setPMux(val | (0 << sam.PORT_GROUP_PMUX_PMUXE_Pos))
-	}
-
-	handleEICInterrupt := func(interrupt.Interrupt) {
-		flags := sam.EIC.INTFLAG.Get()
-		sam.EIC.INTFLAG.Set(flags)      // clear interrupt
-		for i := uint(0); i < 16; i++ { // there are 16 channels
-			if flags&(1<<i) != 0 {
-				pinCallbacks[i](interruptPins[i])
-			}
-		}
-	}
-	switch extint {
-	case 0:
-		interrupt.New(sam.IRQ_EIC_EXTINT_0, handleEICInterrupt).Enable()
-	case 1:
-		interrupt.New(sam.IRQ_EIC_EXTINT_1, handleEICInterrupt).Enable()
-	case 2:
-		interrupt.New(sam.IRQ_EIC_EXTINT_2, handleEICInterrupt).Enable()
-	case 3:
-		interrupt.New(sam.IRQ_EIC_EXTINT_3, handleEICInterrupt).Enable()
-	case 4:
-		interrupt.New(sam.IRQ_EIC_EXTINT_4, handleEICInterrupt).Enable()
-	case 5:
-		interrupt.New(sam.IRQ_EIC_EXTINT_5, handleEICInterrupt).Enable()
-	case 6:
-		interrupt.New(sam.IRQ_EIC_EXTINT_6, handleEICInterrupt).Enable()
-	case 7:
-		interrupt.New(sam.IRQ_EIC_EXTINT_7, handleEICInterrupt).Enable()
-	case 8:
-		interrupt.New(sam.IRQ_EIC_EXTINT_8, handleEICInterrupt).Enable()
-	case 9:
-		interrupt.New(sam.IRQ_EIC_EXTINT_9, handleEICInterrupt).Enable()
-	case 10:
-		interrupt.New(sam.IRQ_EIC_EXTINT_10, handleEICInterrupt).Enable()
-	case 11:
-		interrupt.New(sam.IRQ_EIC_EXTINT_11, handleEICInterrupt).Enable()
-	case 12:
-		interrupt.New(sam.IRQ_EIC_EXTINT_12, handleEICInterrupt).Enable()
-	case 13:
-		interrupt.New(sam.IRQ_EIC_EXTINT_13, handleEICInterrupt).Enable()
-	case 14:
-		interrupt.New(sam.IRQ_EIC_EXTINT_14, handleEICInterrupt).Enable()
-	case 15:
-		interrupt.New(sam.IRQ_EIC_EXTINT_15, handleEICInterrupt).Enable()
-	}
-
-	return nil
-}
-
 // Return the register and mask to enable a given GPIO pin. This can be used to
 // implement bit-banged drivers.
 func (p Pin) PortMaskSet() (*uint32, uint32) {
@@ -826,7 +586,7 @@ func (a ADC) Get() uint16 {
 }
 
 func (a ADC) getADCBus() *sam.ADC_Type {
-	if (a.Pin >= PB04 && a.Pin <= PB07) || (a.Pin >= PC00) {
+	if a.Pin >= PB04 && a.Pin <= PB07 {
 		return sam.ADC1
 	}
 	return sam.ADC0
@@ -869,24 +629,6 @@ func (a ADC) getADCChannel() uint8 {
 		return 8
 	case PB07:
 		return 9
-
-	case PC00:
-		return 10
-	case PC01:
-		return 11
-	case PC02:
-		return 4
-	case PC03:
-		return 5
-	case PC30:
-		return 12
-	case PC31:
-		return 13
-
-	case PD00:
-		return 14
-	case PD01:
-		return 15
 	default:
 		panic("Invalid ADC pin")
 	}
@@ -903,8 +645,28 @@ type UART struct {
 var (
 	// UART0 is actually a USB CDC interface.
 	UART0 = USBCDC{Buffer: NewRingBuffer()}
+
+	// The first hardware serial port on the SAMD51. Uses the SERCOM3 interface.
+	UART1 = UART{
+		Buffer: NewRingBuffer(),
+		Bus:    sam.SERCOM3_USART_INT,
+		SERCOM: 3,
+	}
+
+	// The second hardware serial port on the SAMD51. Uses the SERCOM0 interface.
+	UART2 = UART{
+		Buffer: NewRingBuffer(),
+		Bus:    sam.SERCOM0_USART_INT,
+		SERCOM: 0,
+	}
 )
 
+func init() {
+	// Register RXC interrupts.
+	UART1.Interrupt = interrupt.New(sam.IRQ_SERCOM3_2, UART1.handleInterrupt)
+	UART2.Interrupt = interrupt.New(sam.IRQ_SERCOM0_2, UART2.handleInterrupt)
+}
+
 const (
 	sampleRate16X = 16
 	lsbFirst      = 1
@@ -1454,7 +1216,7 @@ const (
 const period = 0xFFFF
 
 // Configure configures a PWM pin for output.
-func (pwm PWM) Configure() error {
+func (pwm PWM) Configure() {
 	// Set pin as output
 	sam.PORT.GROUP[0].DIRSET.Set(1 << uint8(pwm.Pin))
 	// Set pin to low
@@ -1478,9 +1240,6 @@ func (pwm PWM) Configure() error {
 
 	// figure out which TCCX timer for this pin
 	timer := pwm.getTimer()
-	if timer == nil {
-		return ErrInvalidOutputPin
-	}
 
 	// disable timer
 	timer.CTRLA.ClearBits(sam.TCC_CTRLA_ENABLE)
@@ -1505,7 +1264,7 @@ func (pwm PWM) Configure() error {
 
 	// Set the initial value
 	// TCCx->CC[tcChannel].reg = (uint32_t) value;
-	pwm.setChannel(timer, 0)
+	pwm.setChannel(0)
 
 	for timer.SYNCBUSY.HasBits(sam.TCC_SYNCBUSY_CC0) ||
 		timer.SYNCBUSY.HasBits(sam.TCC_SYNCBUSY_CC1) {
@@ -1523,19 +1282,12 @@ func (pwm PWM) Configure() error {
 	// Wait for synchronization
 	for timer.SYNCBUSY.HasBits(sam.TCC_SYNCBUSY_ENABLE) {
 	}
-
-	return nil
 }
 
 // Set turns on the duty cycle for a PWM pin using the provided value.
 func (pwm PWM) Set(value uint16) {
 	// figure out which TCCX timer for this pin
 	timer := pwm.getTimer()
-	if timer == nil {
-		// The Configure call above cannot have succeeded, so simply ignore this
-		// error.
-		return
-	}
 
 	// Wait for synchronization
 	for timer.SYNCBUSY.HasBits(sam.TCC_SYNCBUSY_CTRLB) {
@@ -1545,7 +1297,7 @@ func (pwm PWM) Set(value uint16) {
 	}
 
 	// TCCx->CCBUF[tcChannel].reg = (uint32_t) value;
-	pwm.setChannelBuffer(timer, uint32(value))
+	pwm.setChannelBuffer(uint32(value))
 
 	for timer.SYNCBUSY.HasBits(sam.TCC_SYNCBUSY_CC0) ||
 		timer.SYNCBUSY.HasBits(sam.TCC_SYNCBUSY_CC1) {
@@ -1577,61 +1329,61 @@ func (pwm PWM) setPinCfg(val uint8) {
 	pwm.Pin.setPinCfg(val)
 }
 
-// setChannel sets the value for the correct channel for PWM on this pin.
-func (pwm PWM) setChannel(timer *sam.TCC_Type, val uint32) {
+// setChannel sets the value for the correct channel for PWM on this pin
+func (pwm PWM) setChannel(val uint32) {
 	switch pwm.Pin {
 	case PA16:
-		timer.CC[0].Set(val)
+		pwm.getTimer().CC[0].Set(val)
 	case PA17:
-		timer.CC[1].Set(val)
+		pwm.getTimer().CC[1].Set(val)
 	case PA14:
-		timer.CC[0].Set(val)
+		pwm.getTimer().CC[0].Set(val)
 	case PA15:
-		timer.CC[1].Set(val)
+		pwm.getTimer().CC[1].Set(val)
 	case PA18:
-		timer.CC[2].Set(val)
+		pwm.getTimer().CC[2].Set(val)
 	case PA19:
-		timer.CC[3].Set(val)
+		pwm.getTimer().CC[3].Set(val)
 	case PA20:
-		timer.CC[0].Set(val)
+		pwm.getTimer().CC[0].Set(val)
 	case PA21:
-		timer.CC[1].Set(val)
+		pwm.getTimer().CC[1].Set(val)
 	case PA23:
-		timer.CC[3].Set(val)
+		pwm.getTimer().CC[3].Set(val)
 	case PA22:
-		timer.CC[2].Set(val)
+		pwm.getTimer().CC[2].Set(val)
 	case PB31:
-		timer.CC[1].Set(val)
+		pwm.getTimer().CC[1].Set(val)
 	default:
 		return // not supported on this pin
 	}
 }
 
 // setChannelBuffer sets the value for the correct channel buffer for PWM on this pin
-func (pwm PWM) setChannelBuffer(timer *sam.TCC_Type, val uint32) {
+func (pwm PWM) setChannelBuffer(val uint32) {
 	switch pwm.Pin {
 	case PA16:
-		timer.CCBUF[0].Set(val)
+		pwm.getTimer().CCBUF[0].Set(val)
 	case PA17:
-		timer.CCBUF[1].Set(val)
+		pwm.getTimer().CCBUF[1].Set(val)
 	case PA14:
-		timer.CCBUF[0].Set(val)
+		pwm.getTimer().CCBUF[0].Set(val)
 	case PA15:
-		timer.CCBUF[1].Set(val)
+		pwm.getTimer().CCBUF[1].Set(val)
 	case PA18:
-		timer.CCBUF[2].Set(val)
+		pwm.getTimer().CCBUF[2].Set(val)
 	case PA19:
-		timer.CCBUF[3].Set(val)
+		pwm.getTimer().CCBUF[3].Set(val)
 	case PA20:
-		timer.CCBUF[0].Set(val)
+		pwm.getTimer().CCBUF[0].Set(val)
 	case PA21:
-		timer.CCBUF[1].Set(val)
+		pwm.getTimer().CCBUF[1].Set(val)
 	case PA23:
-		timer.CCBUF[3].Set(val)
+		pwm.getTimer().CCBUF[3].Set(val)
 	case PA22:
-		timer.CCBUF[2].Set(val)
+		pwm.getTimer().CCBUF[2].Set(val)
 	case PB31:
-		timer.CCBUF[1].Set(val)
+		pwm.getTimer().CCBUF[1].Set(val)
 	default:
 		return // not supported on this pin
 	}

src/machine/machine_atsamd51p19.go

@@ -1,58 +0,0 @@
-// +build sam,atsamd51,atsamd51p19
-
-// Peripheral abstraction layer for the atsamd51.
-//
-// Datasheet:
-// http://ww1.microchip.com/downloads/en/DeviceDoc/60001507C.pdf
-//
-package machine
-
-import "device/sam"
-
-const HSRAM_SIZE = 0x00030000
-
-// InitPWM initializes the PWM interface.
-func InitPWM() {
-	// turn on timer clocks used for PWM
-	sam.MCLK.APBBMASK.SetBits(sam.MCLK_APBBMASK_TCC0_ | sam.MCLK_APBBMASK_TCC1_)
-	sam.MCLK.APBCMASK.SetBits(sam.MCLK_APBCMASK_TCC2_)
-	sam.MCLK.APBDMASK.SetBits(sam.MCLK_APBDMASK_TCC4_)
-
-	//use clock generator 0
-	sam.GCLK.PCHCTRL[25].Set((sam.GCLK_PCHCTRL_GEN_GCLK0 << sam.GCLK_PCHCTRL_GEN_Pos) |
-		sam.GCLK_PCHCTRL_CHEN)
-	sam.GCLK.PCHCTRL[29].Set((sam.GCLK_PCHCTRL_GEN_GCLK0 << sam.GCLK_PCHCTRL_GEN_Pos) |
-		sam.GCLK_PCHCTRL_CHEN)
-	sam.GCLK.PCHCTRL[38].Set((sam.GCLK_PCHCTRL_GEN_GCLK0 << sam.GCLK_PCHCTRL_GEN_Pos) |
-		sam.GCLK_PCHCTRL_CHEN)
-}
-
-// getTimer returns the timer to be used for PWM on this pin
-func (pwm PWM) getTimer() *sam.TCC_Type {
-	switch pwm.Pin {
-	case PA16:
-		return sam.TCC1
-	case PA17:
-		return sam.TCC1
-	case PA14:
-		return sam.TCC2
-	case PA15:
-		return sam.TCC2
-	case PA18:
-		return sam.TCC1
-	case PA19:
-		return sam.TCC1
-	case PA20:
-		return sam.TCC0
-	case PA21:
-		return sam.TCC0
-	case PA23:
-		return sam.TCC0
-	case PA22:
-		return sam.TCC0
-	case PB31:
-		return sam.TCC4
-	default:
-		return nil // not supported on this pin
-	}
-}

src/machine/machine_attiny85.go

@@ -16,8 +16,21 @@ const (
 	PB5
 )
 
-// getPortMask returns the PORTx register and mask for the pin.
+// Configure sets the pin to input or output.
+func (p Pin) Configure(config PinConfig) {
+	if config.Mode == PinOutput { // set output bit
+		avr.DDRB.SetBits(1 << uint8(p))
+	} else { // configure input: clear output bit
+		avr.DDRB.ClearBits(1 << uint8(p))
+	}
+}
+
 func (p Pin) getPortMask() (*volatile.Register8, uint8) {
-	// Very simple for the attiny85, which only has a single port.
 	return avr.PORTB, 1 << uint8(p)
 }
+
+// Get returns the current value of a GPIO pin.
+func (p Pin) Get() bool {
+	val := avr.PINB.Get() & (1 << uint8(p))
+	return (val > 0)
+}

src/machine/machine_avr.go

@@ -5,76 +5,15 @@ package machine
 import (
 	"device/avr"
 	"runtime/volatile"
-	"unsafe"
 )
 
 type PinMode uint8
 
 const (
 	PinInput PinMode = iota
-	PinInputPullup
 	PinOutput
 )
 
-// In all the AVRs I've looked at, the PIN/DDR/PORT registers followed a regular
-// pattern: PINx, DDRx, PORTx in this order without registers in between.
-// Therefore, if you know any of them, you can calculate the other two.
-//
-// For now, I've chosen to let the PORTx register be the one that is returned
-// for each specific chip and to calculate the others from that one. Setting an
-// output port (done using PORTx) is likely the most common operation and the
-// one that is the most time critical. For others, the PINx and DDRx register
-// can trivially be calculated using a subtraction.
-
-// Configure sets the pin to input or output.
-func (p Pin) Configure(config PinConfig) {
-	port, mask := p.getPortMask()
-	// The DDRx register can be found by subtracting one from the PORTx
-	// register, as this appears to be the case for many (most? all?) AVR chips.
-	ddr := (*volatile.Register8)(unsafe.Pointer(uintptr(unsafe.Pointer(port)) - 1))
-	if config.Mode == PinOutput {
-		// set output bit
-		ddr.SetBits(mask)
-
-		// Note: if the pin was PinInputPullup before, it'll now be high.
-		// Otherwise it will be low.
-	} else {
-		// configure input: clear output bit
-		ddr.ClearBits(mask)
-
-		if config.Mode == PinInput {
-			// No pullup (floating).
-			// The transition may be one of the following:
-			//   output high -> input pullup -> input (safe: output high and input pullup are similar)
-			//   output low  -> input        -> input (safe: no extra transition)
-			port.ClearBits(mask)
-		} else {
-			// Pullup.
-			// The transition may be one of the following:
-			//   output high -> input pullup -> input pullup (safe: no extra transition)
-			//   output low  -> input        -> input pullup (possibly problematic)
-			// For the last transition (output low -> input -> input pullup),
-			// the transition may be problematic in some cases because there is
-			// an intermediate floating state (which may cause irratic
-			// interrupts, for example). If this is a problem, the application
-			// should set the pin high before configuring it as PinInputPullup.
-			// We can't do that here because setting it to high as an
-			// intermediate state may have other problems.
-			port.SetBits(mask)
-		}
-	}
-}
-
-// Get returns the current value of a GPIO pin.
-func (p Pin) Get() bool {
-	port, mask := p.getPortMask()
-	// As noted above, the PINx register is always two registers below the PORTx
-	// register, so we can find it simply by subtracting two from the PORTx
-	// register address.
-	pin := (*volatile.Register8)(unsafe.Pointer(uintptr(unsafe.Pointer(port)) - 2)) // PINA, PINB, etc
-	return (pin.Get() & mask) > 0
-}
-
 // Set changes the value of the GPIO pin. The pin must be configured as output.
 func (p Pin) Set(value bool) {
 	if value { // set bits

src/machine/machine_fe310.go

@@ -48,6 +48,7 @@ func (p Pin) Set(high bool) {
 // Get returns the current value of a GPIO pin.
 func (p Pin) Get() bool {
 	val := sifive.GPIO0.VALUE.Get() & (1 << uint8(p))
+	println(sifive.GPIO0.VALUE.Get())
 	return (val > 0)
 }
 

src/machine/machine_generic.go

@@ -90,8 +90,7 @@ func InitPWM() {
 }
 
 // Configure configures a PWM pin for output.
-func (pwm PWM) Configure() error {
-	return nil
+func (pwm PWM) Configure() {
 }
 
 // Set turns on the duty cycle for a PWM pin using the provided value.

src/machine/machine_nrf.go

@@ -21,18 +21,6 @@ const (
 	PinOutput        PinMode = (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
 )
 
-type PinChange uint8
-
-// Pin change interrupt constants for SetInterrupt.
-const (
-	PinRising  PinChange = nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling PinChange = nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle  PinChange = nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-
-// Callbacks to be called for pins configured with SetInterrupt.
-var pinCallbacks [len(nrf.GPIOTE.CONFIG)]func(Pin)
-
 // Configure this pin with the given configuration.
 func (p Pin) Configure(config PinConfig) {
 	cfg := config.Mode | nrf.GPIO_PIN_CNF_DRIVE_S0S1 | nrf.GPIO_PIN_CNF_SENSE_Disabled
@@ -71,65 +59,6 @@ func (p Pin) Get() bool {
 	return (port.IN.Get()>>pin)&1 != 0
 }
 
-// SetInterrupt sets an interrupt to be executed when a particular pin changes
-// state.
-//
-// This call will replace a previously set callback on this pin. You can pass a
-// nil func to unset the pin change interrupt. If you do so, the change
-// parameter is ignored and can be set to any value (such as 0).
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error {
-	// Some variables to easily check whether a channel was already configured
-	// as an event channel for the given pin.
-	// This is not just an optimization, this is requred: the datasheet says
-	// that configuring more than one channel for a given pin results in
-	// unpredictable behavior.
-	expectedConfigMask := uint32(nrf.GPIOTE_CONFIG_MODE_Msk | nrf.GPIOTE_CONFIG_PSEL_Msk)
-	expectedConfig := nrf.GPIOTE_CONFIG_MODE_Event<<nrf.GPIOTE_CONFIG_MODE_Pos | uint32(p)<<nrf.GPIOTE_CONFIG_PSEL_Pos
-
-	foundChannel := false
-	for i := range nrf.GPIOTE.CONFIG {
-		config := nrf.GPIOTE.CONFIG[i].Get()
-		if config == 0 || config&expectedConfigMask == expectedConfig {
-			// Found an empty GPIOTE channel or one that was already configured
-			// for this pin.
-			if callback == nil {
-				// Disable this channel.
-				nrf.GPIOTE.INTENCLR.Set(uint32(1 << uint(i)))
-				pinCallbacks[i] = nil
-				return nil
-			}
-			// Enable this channel with the given callback.
-			nrf.GPIOTE.INTENCLR.Set(uint32(1 << uint(i)))
-			nrf.GPIOTE.CONFIG[i].Set(nrf.GPIOTE_CONFIG_MODE_Event<<nrf.GPIOTE_CONFIG_MODE_Pos |
-				uint32(p)<<nrf.GPIOTE_CONFIG_PSEL_Pos |
-				uint32(change)<<nrf.GPIOTE_CONFIG_POLARITY_Pos)
-			pinCallbacks[i] = callback
-			nrf.GPIOTE.INTENSET.Set(uint32(1 << uint(i)))
-			foundChannel = true
-			break
-		}
-	}
-
-	if !foundChannel {
-		return ErrNoPinChangeChannel
-	}
-
-	// Set and enable the GPIOTE interrupt. It's not a problem if this happens
-	// more than once.
-	interrupt.New(nrf.IRQ_GPIOTE, func(interrupt.Interrupt) {
-		for i := range nrf.GPIOTE.EVENTS_IN {
-			if nrf.GPIOTE.EVENTS_IN[i].Get() != 0 {
-				nrf.GPIOTE.EVENTS_IN[i].Set(0)
-				pin := Pin((nrf.GPIOTE.CONFIG[i].Get() & nrf.GPIOTE_CONFIG_PSEL_Msk) >> nrf.GPIOTE_CONFIG_PSEL_Pos)
-				pinCallbacks[i](pin)
-			}
-		}
-	}).Enable()
-
-	// Everything was configured correctly.
-	return nil
-}
-
 // UART on the NRF.
 type UART struct {
 	Buffer *RingBuffer
@@ -443,13 +372,13 @@ func (spi SPI) Tx(w, r []byte) error {
 			spi.Bus.TXD.Set(uint32(b))
 			for spi.Bus.EVENTS_READY.Get() == 0 {
 			}
-			spi.Bus.EVENTS_READY.Set(0)
 			_ = spi.Bus.RXD.Get()
+			spi.Bus.EVENTS_READY.Set(0)
 		}
 		for spi.Bus.EVENTS_READY.Get() == 0 {
 		}
-		spi.Bus.EVENTS_READY.Set(0)
 		_ = spi.Bus.RXD.Get()
+		spi.Bus.EVENTS_READY.Set(0)
 
 	default:
 		// write/read

src/machine/machine_nrf52.go

@@ -159,8 +159,7 @@ func InitPWM() {
 }
 
 // Configure configures a PWM pin for output.
-func (pwm PWM) Configure() error {
-	return nil
+func (pwm PWM) Configure() {
 }
 
 // Set turns on the duty cycle for a PWM pin using the provided value.

src/machine/machine_nrf52840.go

@@ -104,8 +104,8 @@ func InitADC() {
 }
 
 // Configure configures an ADC pin to be able to read analog data.
-func (a ADC) Configure() error {
-	return nil // no pin specific setup on nrf52840 machine.
+func (a ADC) Configure() {
+	return // no pin specific setup on nrf52840 machine.
 }
 
 // Get returns the current value of a ADC pin in the range 0..0xffff.

src/os/env.go

@@ -1,5 +0,0 @@
-package os
-
-func Getenv(key string) string {
-	return ""
-}

src/os/errors.go

@@ -1,39 +0,0 @@
-package os
-
-import (
-	"errors"
-)
-
-var (
-	ErrInvalid    = errors.New("invalid argument")
-	ErrPermission = errors.New("permission denied")
-	ErrClosed     = errors.New("file already closed")
-
-	// Portable analogs of some common system call errors.
-	// Note that these are exported for use in the Filesystem interface.
-	ErrUnsupported    = errors.New("operation not supported")
-	ErrNotImplemented = errors.New("operation not implemented")
-	ErrNotExist       = errors.New("file not found")
-	ErrExist          = errors.New("file exists")
-)
-
-func IsPermission(err error) bool {
-	return err == ErrPermission
-}
-
-func NewSyscallError(syscall string, err error) error {
-	if err == nil {
-		return nil
-	}
-	return &SyscallError{syscall, err}
-}
-
-// SyscallError records an error from a specific system call.
-type SyscallError struct {
-	Syscall string
-	Err     error
-}
-
-func (e *SyscallError) Error() string { return e.Syscall + ": " + e.Err.Error() }
-
-func (e *SyscallError) Unwrap() error { return e.Err }

src/os/exec.go

@@ -1,6 +0,0 @@
-package os
-
-type Signal interface {
-	String() string
-	Signal() // to distinguish from other Stringers
-}