main: version 0.6.0

This should fix compatibility with the Go 1.12 stdlib:
https://github.com/tinygo-org/tinygo/issues/368

.circleci/config.yml

@@ -40,53 +40,36 @@ 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
-  dep:
+  llvm-source-linux:
     steps:
+      - restore_cache:
+          keys:
+            - llvm-source-8-v3
       - run:
-          name: "Install Go dependencies"
-          command: |
-            curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
-            dep ensure --vendor-only
+          name: "Fetch LLVM source"
+          command: make llvm-source
+      - save_cache:
+          key: llvm-source-8-v3
+          paths:
+            - llvm
   smoketest:
     steps:
-      - smoketest-no-avr
-      - run: tinygo build -size short -o test.elf -target=arduino             examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=digispark           examples/blinky1
+      - run: make smoketest
   smoketest-no-avr:
     steps:
-      - run: tinygo build -size short -o test.elf -target=pca10040            examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=pca10040            examples/blinky2
-      - run: tinygo build             -o blinky2                              examples/blinky2 # TODO: re-enable -size flag with MachO support
-      - run: tinygo build -size short -o test.elf -target=pca10040            examples/test
-      - run: tinygo build -size short -o test.elf -target=microbit            examples/echo
-      - run: tinygo build -size short -o test.elf -target=nrf52840-mdk        examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=pca10031            examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=bluepill            examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=reelboard           examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=reelboard           examples/blinky2
-      - run: tinygo build -size short -o test.elf -target=pca10056            examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=pca10056            examples/blinky2
-      - run: tinygo build -size short -o test.elf -target=itsybitsy-m0        examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=circuitplay-express examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=stm32f4disco        examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=stm32f4disco        examples/blinky2
-      - run: tinygo build             -o wasm.wasm -target=wasm               examples/wasm/export
-      - run: tinygo build             -o wasm.wasm -target=wasm               examples/wasm/main
+      - run: make smoketest-no-avr
   test-linux:
-    parameters:
-      llvm:
-        type: string
     steps:
       - checkout
       - submodules
       - apt-dependencies:
-          llvm: <<parameters.llvm>>
+          llvm: "-8"
       - install-node
       - restore_cache:
           keys:
             - go-cache-{{ checksum "Gopkg.lock" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
             - go-cache-{{ checksum "Gopkg.lock" }}
-      - dep
+      - llvm-source-linux
       - run: go install .
       - run: go test -v
       - run: make gen-device -j4
@@ -105,7 +88,6 @@ commands:
           name: "Install apt dependencies"
           command: |
             sudo apt-get install \
-                libtinfo-dev \
                 python3 \
                 gcc-arm-linux-gnueabihf \
                 binutils-arm-none-eabi \
@@ -121,19 +103,10 @@ commands:
           keys:
             - go-cache-{{ checksum "Gopkg.lock" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
             - go-cache-{{ checksum "Gopkg.lock" }}
+      - llvm-source-linux
       - restore_cache:
           keys:
-            - llvm-source-8-v2
-      - run:
-          name: "Fetch LLVM source"
-          command: make llvm-source
-      - save_cache:
-          key: llvm-source-8-v2
-          paths:
-            - llvm
-      - restore_cache:
-          keys:
-            - llvm-build-8-v2
+            - llvm-build-8-linux-v5
       - run:
           name: "Build LLVM"
           command: |
@@ -151,7 +124,7 @@ commands:
               make llvm-build
             fi
       - save_cache:
-          key: llvm-build-8-v2
+          key: llvm-build-8-linux-v5
           paths:
             llvm-build
       - run:
@@ -160,7 +133,6 @@ commands:
             ln -s $PWD/llvm-build/bin/clang-8 /go/bin/clang-8
             ln -s $PWD/llvm-build/bin/ld.lld  /go/bin/ld.lld-8
             ln -s $PWD/llvm-build/bin/wasm-ld /go/bin/wasm-ld-8
-      - dep
       - run:
           name: "Test TinyGo"
           command: make test
@@ -191,20 +163,23 @@ commands:
       - run:
           name: "Install dependencies"
           command: |
-            HOMEBREW_NO_AUTO_UPDATE=1 brew install go dep qemu
+            curl https://dl.google.com/go/go1.12.5.darwin-amd64.tar.gz -o go1.12.5.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.12.5.darwin-amd64.tar.gz
+            ln -s /usr/local/go/bin/go /usr/local/bin/go
+            HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu
       - restore_cache:
           keys:
-            - llvm-source-8-macos-v2
+            - llvm-source-8-macos-v3
       - run:
           name: "Fetch LLVM source"
           command: make llvm-source
       - save_cache:
-          key: llvm-source-8-macos-v2
+          key: llvm-source-8-macos-v3
           paths:
             - llvm
       - restore_cache:
           keys:
-            - llvm-build-8-macos-v2
+            - llvm-build-8-macos-v4
       - run:
           name: "Build LLVM"
           command: |
@@ -216,16 +191,13 @@ commands:
               make llvm-build
             fi
       - save_cache:
-          key: llvm-build-8-macos-v2
+          key: llvm-build-8-macos-v4
           paths:
             llvm-build
       - run:
           name: "Create LLVM symlinks"
           command: |
             ln -s $PWD/llvm-build/bin/clang-8 /usr/local/bin/clang-8
-      - run:
-          name: "Install Go dependencies"
-          command: dep ensure --vendor-only
       - run:
           name: "Test TinyGo"
           command: make test
@@ -250,27 +222,21 @@ jobs:
   test-llvm8-go111:
     docker:
       - image: circleci/golang:1.11
-    working_directory: /go/src/github.com/tinygo-org/tinygo
     steps:
-      - test-linux:
-          llvm: "-8"
+      - test-linux
   test-llvm8-go112:
     docker:
       - image: circleci/golang:1.12
-    working_directory: /go/src/github.com/tinygo-org/tinygo
     steps:
-      - test-linux:
-          llvm: "-8"
+      - test-linux
   build-linux:
     docker:
       - image: circleci/golang:1.12
-    working_directory: /go/src/github.com/tinygo-org/tinygo
     steps:
       - build-linux
   build-macos:
     macos:
       xcode: "10.1.0"
-    working_directory: ~/go/src/github.com/tinygo-org/tinygo
     steps:
       - build-macos
 

.gitignore

@@ -10,3 +10,5 @@ src/device/stm32/*.s
 src/device/sam/*.go
 src/device/sam/*.s
 vendor
+llvm
+llvm-build

CHANGELOG.md

@@ -1,3 +1,52 @@
+0.6.0
+---
+* **command line**
+  - some portability improvements
+  - make `$GOROOT` more robust and configurable
+  - check for Clang at the Homebrew install location as fallback
+* **compiler driver**
+  - support multiple variations of LLVM commands, for non-Debian distributions
+* **compiler**
+  - improve code quality in multiple ways
+  - make panic configurable, adding trap on panic
+  - refactor many internal parts of the compiler
+  - print all errors encountered during compilation
+  - implement calling function values of a named type
+  - implement returning values from blocking functions
+  - allow larger-than-int values to be sent across a channel
+  - implement complex arithmetic
+  - improve hashmap support
+  - add debuginfo for function arguments
+  - insert nil checks on stores (increasing code size)
+  - implement volatile operations as compiler builtins
+  - add `//go:inline` pragma
+  - add build tags for the Go stdlib version
+* **cgo**
+  - implement `char`, `enum` and `void*` types
+  - support `#include` for builtin headers
+  - improve typedef/struct/enum support
+  - only include symbols that are necessary, for broader support
+  - mark external function args as `nocapture`
+  - implement support for some `#define` constants
+  - implement support for multiple CGo files in a single package
+- **standard library**
+  - `machine`: remove microbit matrix (moved to drivers repository)
+  - `machine`: refactor pins to use `Pin` type instead of `GPIO`
+  - `runtime`: print more interface types on panic, including `error`
+* **targets**
+  - `arm`: print an error on HardFault (including stack overflows)
+  - `atsamd21`: fix a bug in the ADC peripheral
+  - `atsamd21`: add support for I2S
+  - `feather-m0`: add support for this board
+  - `nrf51`: fix a bug in I2C
+  - `stm32f103xx`: fix a bug in I2C
+  - `syscall`: implement `Exit` on unix
+  - `trinket-m0`: add support for this board
+  - `wasm`: make _main_ example smaller
+  - `wasm`: don't cache wasm file in the server, for ease of debugging
+  - `wasm`: work around bug #41508 that caused a deadlock while linking
+  - `wasm`: add support for `js.FuncOf`
+
 0.5.0
 ---
 - **compiler driver**

Dockerfile

@@ -10,8 +10,11 @@ RUN wget -O- https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
 
 COPY . /go/src/github.com/tinygo-org/tinygo
 
+# remove submodules directories and re-init them to fix any hard-coded paths
+# after copying the tinygo directory in the previous step.
 RUN cd /go/src/github.com/tinygo-org/tinygo/ && \
-    git submodule update --init
+    rm -rf ./lib/* && \
+    git submodule update --init --recursive --force
 
 RUN cd /go/src/github.com/tinygo-org/tinygo/ && \
     dep ensure --vendor-only && \
@@ -43,7 +46,7 @@ RUN cd /go/src/github.com/tinygo-org/tinygo/ && \
     apt-get update && \
     apt-get install -y apt-utils python3 make binutils-avr gcc-avr avr-libc && \
     make gen-device-avr && \
-    apt-get remove -y python3 make && \
+    apt-get remove -y python3 && \
     apt-get autoremove -y && \
     apt-get clean
 
@@ -61,7 +64,7 @@ RUN cd /go/src/github.com/tinygo-org/tinygo/ && \
     apt-get update && \
     apt-get install -y apt-utils python3 make clang-8 && \
     make gen-device-nrf && make gen-device-stm32 && \
-    apt-get remove -y python3 make && \
+    apt-get remove -y python3 && \
     apt-get autoremove -y && \
     apt-get clean
 
@@ -76,7 +79,7 @@ RUN cd /go/src/github.com/tinygo-org/tinygo/ && \
     apt-get update && \
     apt-get install -y apt-utils python3 make clang-8 binutils-avr gcc-avr avr-libc && \
     make gen-device && \
-    apt-get remove -y python3 make && \
+    apt-get remove -y python3 && \
     apt-get autoremove -y && \
     apt-get clean
 

LICENSE

@@ -1,5 +1,8 @@
 Copyright (c) 2018-2019 TinyGo Authors. All rights reserved.
 
+TinyGo includes portions of the Go standard library.
+Copyright (c) 2009-2019 The Go Authors. All rights reserved.
+
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:

Makefile

@@ -32,7 +32,7 @@ CGO_LDFLAGS=-L$(LLVM_BUILDDIR)/lib $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUIL
 clean:
 	@rm -rf build
 
-FMT_PATHS = ./*.go compiler interp ir loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall
+FMT_PATHS = ./*.go cgo compiler interp ir loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall
 fmt:
 	@gofmt -l -w $(FMT_PATHS)
 fmt-check:
@@ -69,7 +69,7 @@ llvm-source: llvm/README.txt llvm/tools/clang/README.txt llvm/tools/lld/README.m
 
 # Configure LLVM.
 llvm-build/build.ninja: llvm-source
-	mkdir -p llvm-build; cd llvm-build; cmake -G Ninja ../llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR" -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=OFF -DLIBCLANG_BUILD_STATIC=ON
+	mkdir -p llvm-build; cd llvm-build; cmake -G Ninja ../llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR" -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=OFF -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF
 
 # Build LLVM.
 llvm-build: llvm-build/build.ninja
@@ -84,15 +84,57 @@ build/tinygo:
 test:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" go test -v -tags byollvm .
 
+.PHONY: smoketest smoketest-no-avr
+smoketest: smoketest-no-avr
+	tinygo build -size short -o test.elf -target=arduino             examples/blinky1
+	tinygo build -size short -o test.elf -target=digispark           examples/blinky1
+smoketest-no-avr:
+	# test all examples
+	tinygo build -size short -o test.elf -target=pca10040            examples/blinky1
+	tinygo build -size short -o test.elf -target=pca10040            examples/adc
+	tinygo build -size short -o test.elf -target=pca10040            examples/blinkm
+	tinygo build -size short -o test.elf -target=pca10040            examples/blinky2
+	tinygo build -size short -o test.elf -target=pca10040            examples/button
+	tinygo build -size short -o test.elf -target=pca10040            examples/button2
+	tinygo build -size short -o test.elf -target=pca10040            examples/echo
+	tinygo build -size short -o test.elf -target=circuitplay-express examples/i2s
+	tinygo build -size short -o test.elf -target=pca10040            examples/mcp3008
+	tinygo build -size short -o test.elf -target=microbit            examples/microbit-blink
+	tinygo build -size short -o test.elf -target=pca10040            examples/pwm
+	tinygo build -size short -o test.elf -target=pca10040            examples/serial
+	tinygo build -size short -o test.elf -target=pca10040            examples/test
+	# test all targets/boards
+	tinygo build             -o test.elf                             examples/blinky2 # TODO: re-enable -size flag with MachO support
+	tinygo build -size short -o test.elf -target=microbit            examples/echo
+	tinygo build -size short -o test.elf -target=nrf52840-mdk        examples/blinky1
+	tinygo build -size short -o test.elf -target=pca10031            examples/blinky1
+	tinygo build -size short -o test.elf -target=bluepill            examples/blinky1
+	tinygo build -size short -o test.elf -target=reelboard           examples/blinky1
+	tinygo build -size short -o test.elf -target=reelboard           examples/blinky2
+	tinygo build -size short -o test.elf -target=pca10056            examples/blinky1
+	tinygo build -size short -o test.elf -target=pca10056            examples/blinky2
+	tinygo build -size short -o test.elf -target=itsybitsy-m0        examples/blinky1
+	tinygo build -size short -o test.elf -target=feather-m0          examples/blinky1
+	tinygo build -size short -o test.elf -target=trinket-m0          examples/blinky1
+	tinygo build -size short -o test.elf -target=circuitplay-express examples/blinky1
+	tinygo build -size short -o test.elf -target=stm32f4disco        examples/blinky1
+	tinygo build -size short -o test.elf -target=stm32f4disco        examples/blinky2
+	tinygo build -size short -o test.elf -target=circuitplay-express examples/i2s
+	tinygo build             -o wasm.wasm -target=wasm               examples/wasm/export
+	tinygo build             -o wasm.wasm -target=wasm               examples/wasm/main
+
 release: build/tinygo gen-device
 	@mkdir -p build/release/tinygo/bin
+	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
 	@mkdir -p build/release/tinygo/lib/compiler-rt/lib
 	@mkdir -p build/release/tinygo/lib/nrfx
 	@mkdir -p build/release/tinygo/pkg/armv6m-none-eabi
 	@mkdir -p build/release/tinygo/pkg/armv7m-none-eabi
 	@mkdir -p build/release/tinygo/pkg/armv7em-none-eabi
+	@echo copying source files
 	@cp -p  build/tinygo                 build/release/tinygo/bin
+	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
 	@cp -rp lib/CMSIS/CMSIS/Include      build/release/tinygo/lib/CMSIS/CMSIS
 	@cp -rp lib/CMSIS/README.md          build/release/tinygo/lib/CMSIS
 	@cp -rp lib/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt/lib

README.md

@@ -17,8 +17,8 @@ import (
 )
 
 func main() {
-    led := machine.GPIO{machine.LED}
-    led.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+    led := machine.LED
+    led.Configure(machine.PinConfig{Mode: machine.PinOutput})
     for {
         led.Low()
         time.Sleep(time.Millisecond * 1000)
@@ -43,13 +43,16 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for
 
 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.
 
-The following microcontroller boards are currently supported:
+The following 14 microcontroller boards are currently supported:
 
 * [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)
+* [Adafruit Feather M0](https://www.adafruit.com/product/2772)
 * [Adafruit ItsyBitsy M0](https://www.adafruit.com/product/3727)
+* [Adafruit Trinket M0](https://www.adafruit.com/product/3500)
 * [Arduino Uno](https://store.arduino.cc/arduino-uno-rev3)
-* [BBC:Microbit](https://microbit.org/)
+* [BBC micro:bit](https://microbit.org/)
 * [ST Micro STM32F103XX "Bluepill"](http://wiki.stm32duino.com/index.php?title=Blue_Pill)
+* [ST Micro STM32F407 "Discovery"](https://www.st.com/en/evaluation-tools/stm32f4discovery.html)
 * [Digispark](http://digistump.com/products/1)
 * [Nordic Semiconductor PCA10031](https://www.nordicsemi.com/eng/Products/nRF51-Dongle)
 * [Nordic Semiconductor PCA10040](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52-DK)

buildcache.go

@@ -9,9 +9,11 @@ import (
 
 // Get the cache directory, usually ~/.cache/tinygo
 func cacheDir() string {
-	home := getHomeDir()
-	dir := filepath.Join(home, ".cache", "tinygo")
-	return dir
+	dir, err := os.UserCacheDir()
+	if err != nil {
+		panic("could not find cache dir: " + err.Error())
+	}
+	return filepath.Join(dir, "tinygo")
 }
 
 // Return the newest timestamp of all the file paths passed in. Used to check

builtins.go

@@ -5,7 +5,6 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
 	"time"
@@ -192,13 +191,13 @@ func loadBuiltins(target string) (path string, err error) {
 		srcs[i] = filepath.Join(builtinsDir, name)
 	}
 
-	if path, err := cacheLoad(outfile, commands["clang"], srcs); path != "" || err != nil {
+	if path, err := cacheLoad(outfile, commands["clang"][0], srcs); path != "" || err != nil {
 		return path, err
 	}
 
 	var cachepath string
 	err = compileBuiltins(target, func(path string) error {
-		path, err := cacheStore(path, outfile, commands["clang"], srcs)
+		path, err := cacheStore(path, outfile, commands["clang"][0], srcs)
 		cachepath = path
 		return err
 	})
@@ -240,11 +239,7 @@ func compileBuiltins(target string, callback func(path string) error) error {
 		// Note: -fdebug-prefix-map is necessary to make the output archive
 		// reproducible. Otherwise the temporary directory is stored in the
 		// archive itself, which varies each run.
-		cmd := exec.Command(commands["clang"], "-c", "-Oz", "-g", "-Werror", "-Wall", "-std=c11", "-fshort-enums", "-nostdlibinc", "-ffunction-sections", "-fdata-sections", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir, "-o", objpath, srcpath)
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		cmd.Dir = dir
-		err = cmd.Run()
+		err := execCommand(commands["clang"], "-c", "-Oz", "-g", "-Werror", "-Wall", "-std=c11", "-fshort-enums", "-nostdlibinc", "-ffunction-sections", "-fdata-sections", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir, "-o", objpath, srcpath)
 		if err != nil {
 			return &commandError{"failed to build", srcpath, err}
 		}
@@ -294,5 +289,6 @@ func compileBuiltins(target string, callback func(path string) error) error {
 
 	// Give the caller the resulting file. The callback must copy the file,
 	// because after it returns the temporary directory will be removed.
+	arfile.Close()
 	return callback(arpath)
 }

cgo/cgo.go

@@ -0,0 +1,695 @@
+// Package cgo implements CGo by modifying a loaded AST. It does this by parsing
+// the `import "C"` statements found in the source code with libclang and
+// generating stub function and global declarations.
+//
+// There are a few advantages to modifying the AST directly instead of doing CGo
+// as a preprocessing step, with the main advantage being that debug information
+// is kept intact as much as possible.
+package cgo
+
+// This file extracts the `import "C"` statement from the source and modifies
+// the AST for CGo. It does not use libclang directly: see libclang.go for the C
+// source file parsing.
+
+import (
+	"go/ast"
+	"go/token"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/ast/astutil"
+)
+
+// cgoPackage holds all CGo-related information of a package.
+type cgoPackage struct {
+	generated       *ast.File
+	generatedPos    token.Pos
+	errors          []error
+	dir             string
+	fset            *token.FileSet
+	tokenFiles      map[string]*token.File
+	missingSymbols  map[string]struct{}
+	constants       map[string]constantInfo
+	functions       map[string]*functionInfo
+	globals         map[string]globalInfo
+	typedefs        map[string]*typedefInfo
+	elaboratedTypes map[string]*elaboratedTypeInfo
+	enums           map[string]enumInfo
+}
+
+// constantInfo stores some information about a CGo constant found by libclang
+// and declared in the Go AST.
+type constantInfo struct {
+	expr *ast.BasicLit
+	pos  token.Pos
+}
+
+// functionInfo stores some information about a CGo function found by libclang
+// and declared in the AST.
+type functionInfo struct {
+	args    []paramInfo
+	results *ast.FieldList
+	pos     token.Pos
+}
+
+// paramInfo is a parameter of a CGo function (see functionInfo).
+type paramInfo struct {
+	name     string
+	typeExpr ast.Expr
+}
+
+// typedefInfo contains information about a single typedef in C.
+type typedefInfo struct {
+	typeExpr ast.Expr
+	pos      token.Pos
+}
+
+// elaboratedTypeInfo contains some information about an elaborated type
+// (struct, union) found in the C AST.
+type elaboratedTypeInfo struct {
+	typeExpr ast.Expr
+	pos      token.Pos
+}
+
+// enumInfo contains information about an enum in the C.
+type enumInfo struct {
+	typeExpr ast.Expr
+	pos      token.Pos
+}
+
+// globalInfo contains information about a declared global variable in C.
+type globalInfo struct {
+	typeExpr ast.Expr
+	pos      token.Pos
+}
+
+// cgoAliases list type aliases between Go and C, for types that are equivalent
+// in both languages. See addTypeAliases.
+var cgoAliases = map[string]string{
+	"C.int8_t":    "int8",
+	"C.int16_t":   "int16",
+	"C.int32_t":   "int32",
+	"C.int64_t":   "int64",
+	"C.uint8_t":   "uint8",
+	"C.uint16_t":  "uint16",
+	"C.uint32_t":  "uint32",
+	"C.uint64_t":  "uint64",
+	"C.uintptr_t": "uintptr",
+}
+
+// builtinAliases are handled specially because they only exist on the Go side
+// of CGo, not on the CGo side (they're prefixed with "_Cgo_" there).
+var builtinAliases = map[string]struct{}{
+	"char":      struct{}{},
+	"schar":     struct{}{},
+	"uchar":     struct{}{},
+	"short":     struct{}{},
+	"ushort":    struct{}{},
+	"int":       struct{}{},
+	"uint":      struct{}{},
+	"long":      struct{}{},
+	"ulong":     struct{}{},
+	"longlong":  struct{}{},
+	"ulonglong": struct{}{},
+}
+
+// cgoTypes lists some C types with ambiguous sizes that must be retrieved
+// somehow from C. This is done by adding some typedefs to get the size of each
+// type.
+const cgoTypes = `
+typedef char                _Cgo_char;
+typedef signed char         _Cgo_schar;
+typedef unsigned char       _Cgo_uchar;
+typedef short               _Cgo_short;
+typedef unsigned short      _Cgo_ushort;
+typedef int                 _Cgo_int;
+typedef unsigned int        _Cgo_uint;
+typedef long                _Cgo_long;
+typedef unsigned long       _Cgo_ulong;
+typedef long long           _Cgo_longlong;
+typedef unsigned long long  _Cgo_ulonglong;
+`
+
+// Process extracts `import "C"` statements from the AST, parses the comment
+// with libclang, and modifies the AST to use this information. It returns a
+// 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, []error) {
+	p := &cgoPackage{
+		dir:             dir,
+		fset:            fset,
+		tokenFiles:      map[string]*token.File{},
+		missingSymbols:  map[string]struct{}{},
+		constants:       map[string]constantInfo{},
+		functions:       map[string]*functionInfo{},
+		globals:         map[string]globalInfo{},
+		typedefs:        map[string]*typedefInfo{},
+		elaboratedTypes: map[string]*elaboratedTypeInfo{},
+		enums:           map[string]enumInfo{},
+	}
+
+	// Add a new location for the following file.
+	generatedTokenPos := p.fset.AddFile(dir+"/!cgo.go", -1, 0)
+	generatedTokenPos.SetLines([]int{0})
+	p.generatedPos = generatedTokenPos.Pos(0)
+
+	// Construct a new in-memory AST for CGo declarations of this package.
+	unsafeImport := &ast.ImportSpec{
+		Path: &ast.BasicLit{
+			ValuePos: p.generatedPos,
+			Kind:     token.STRING,
+			Value:    "\"unsafe\"",
+		},
+		EndPos: p.generatedPos,
+	}
+	p.generated = &ast.File{
+		Package: p.generatedPos,
+		Name: &ast.Ident{
+			NamePos: p.generatedPos,
+			Name:    files[0].Name.Name,
+		},
+		Decls: []ast.Decl{
+			&ast.GenDecl{
+				TokPos: p.generatedPos,
+				Tok:    token.IMPORT,
+				Specs: []ast.Spec{
+					unsafeImport,
+				},
+			},
+		},
+		Imports: []*ast.ImportSpec{unsafeImport},
+	}
+
+	// Find all C.* symbols.
+	for _, f := range files {
+		astutil.Apply(f, p.findMissingCGoNames, nil)
+	}
+	for name := range builtinAliases {
+		p.missingSymbols["_Cgo_"+name] = struct{}{}
+	}
+
+	// Find `import "C"` statements in the file.
+	for _, f := range files {
+		for i := 0; i < len(f.Decls); i++ {
+			decl := f.Decls[i]
+			genDecl, ok := decl.(*ast.GenDecl)
+			if !ok {
+				continue
+			}
+			if len(genDecl.Specs) != 1 {
+				continue
+			}
+			spec, ok := genDecl.Specs[0].(*ast.ImportSpec)
+			if !ok {
+				continue
+			}
+			path, err := strconv.Unquote(spec.Path.Value)
+			if err != nil {
+				panic("could not parse import path: " + err.Error())
+			}
+			if path != "C" {
+				continue
+			}
+			cgoComment := genDecl.Doc.Text()
+
+			pos := genDecl.Pos()
+			if genDecl.Doc != nil {
+				pos = genDecl.Doc.Pos()
+			}
+			position := fset.PositionFor(pos, true)
+			p.parseFragment(cgoComment+cgoTypes, cflags, position.Filename, position.Line)
+
+			// Remove this import declaration.
+			f.Decls = append(f.Decls[:i], f.Decls[i+1:]...)
+			i--
+		}
+
+		// Print the AST, for debugging.
+		//ast.Print(fset, f)
+	}
+
+	// Declare functions found by libclang.
+	p.addFuncDecls()
+
+	// Declare stub function pointer values found by libclang.
+	p.addFuncPtrDecls()
+
+	// Declare globals found by libclang.
+	p.addConstDecls()
+
+	// Declare globals found by libclang.
+	p.addVarDecls()
+
+	// Forward C types to Go types (like C.uint32_t -> uint32).
+	p.addTypeAliases()
+
+	// Add type declarations for C types, declared using typedef in C.
+	p.addTypedefs()
+
+	// Add elaborated types for C structs and unions.
+	p.addElaboratedTypes()
+
+	// Add enum types and enum constants for C enums.
+	p.addEnumTypes()
+
+	// Patch the AST to use the declared types and functions.
+	for _, f := range files {
+		astutil.Apply(f, p.walker, nil)
+	}
+
+	// Print the newly generated in-memory AST, for debugging.
+	//ast.Print(fset, p.generated)
+
+	return p.generated, p.errors
+}
+
+// addFuncDecls adds the C function declarations found by libclang in the
+// comment above the `import "C"` statement.
+func (p *cgoPackage) addFuncDecls() {
+	names := make([]string, 0, len(p.functions))
+	for name := range p.functions {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		fn := p.functions[name]
+		obj := &ast.Object{
+			Kind: ast.Fun,
+			Name: "C." + name,
+		}
+		args := make([]*ast.Field, len(fn.args))
+		decl := &ast.FuncDecl{
+			Name: &ast.Ident{
+				NamePos: fn.pos,
+				Name:    "C." + name,
+				Obj:     obj,
+			},
+			Type: &ast.FuncType{
+				Func: fn.pos,
+				Params: &ast.FieldList{
+					Opening: fn.pos,
+					List:    args,
+					Closing: fn.pos,
+				},
+				Results: fn.results,
+			},
+		}
+		obj.Decl = decl
+		for i, arg := range fn.args {
+			args[i] = &ast.Field{
+				Names: []*ast.Ident{
+					&ast.Ident{
+						NamePos: fn.pos,
+						Name:    arg.name,
+						Obj: &ast.Object{
+							Kind: ast.Var,
+							Name: arg.name,
+							Decl: decl,
+						},
+					},
+				},
+				Type: arg.typeExpr,
+			}
+		}
+		p.generated.Decls = append(p.generated.Decls, decl)
+	}
+}
+
+// addFuncPtrDecls creates stub declarations of function pointer values. These
+// values will later be replaced with the real values in the compiler.
+// It adds code like the following to the AST:
+//
+//     var (
+//         C.add unsafe.Pointer
+//         C.mul unsafe.Pointer
+//         // ...
+//     )
+func (p *cgoPackage) addFuncPtrDecls() {
+	if len(p.functions) == 0 {
+		return
+	}
+	gen := &ast.GenDecl{
+		TokPos: token.NoPos,
+		Tok:    token.VAR,
+		Lparen: token.NoPos,
+		Rparen: token.NoPos,
+	}
+	names := make([]string, 0, len(p.functions))
+	for name := range p.functions {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		fn := p.functions[name]
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: "C." + name + "$funcaddr",
+		}
+		valueSpec := &ast.ValueSpec{
+			Names: []*ast.Ident{&ast.Ident{
+				NamePos: fn.pos,
+				Name:    "C." + name + "$funcaddr",
+				Obj:     obj,
+			}},
+			Type: &ast.SelectorExpr{
+				X: &ast.Ident{
+					NamePos: fn.pos,
+					Name:    "unsafe",
+				},
+				Sel: &ast.Ident{
+					NamePos: fn.pos,
+					Name:    "Pointer",
+				},
+			},
+		}
+		obj.Decl = valueSpec
+		gen.Specs = append(gen.Specs, valueSpec)
+	}
+	p.generated.Decls = append(p.generated.Decls, gen)
+}
+
+// addConstDecls declares external C constants in the Go source.
+// It adds code like the following to the AST:
+//
+//     const (
+//         C.CONST_INT = 5
+//         C.CONST_FLOAT = 5.8
+//         // ...
+//     )
+func (p *cgoPackage) addConstDecls() {
+	if len(p.constants) == 0 {
+		return
+	}
+	gen := &ast.GenDecl{
+		TokPos: token.NoPos,
+		Tok:    token.CONST,
+		Lparen: token.NoPos,
+		Rparen: token.NoPos,
+	}
+	names := make([]string, 0, len(p.constants))
+	for name := range p.constants {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		constVal := p.constants[name]
+		obj := &ast.Object{
+			Kind: ast.Con,
+			Name: "C." + name,
+		}
+		valueSpec := &ast.ValueSpec{
+			Names: []*ast.Ident{&ast.Ident{
+				NamePos: constVal.pos,
+				Name:    "C." + name,
+				Obj:     obj,
+			}},
+			Values: []ast.Expr{constVal.expr},
+		}
+		obj.Decl = valueSpec
+		gen.Specs = append(gen.Specs, valueSpec)
+	}
+	p.generated.Decls = append(p.generated.Decls, gen)
+}
+
+// addVarDecls declares external C globals in the Go source.
+// It adds code like the following to the AST:
+//
+//     var (
+//         C.globalInt  int
+//         C.globalBool bool
+//         // ...
+//     )
+func (p *cgoPackage) addVarDecls() {
+	if len(p.globals) == 0 {
+		return
+	}
+	gen := &ast.GenDecl{
+		TokPos: token.NoPos,
+		Tok:    token.VAR,
+		Lparen: token.NoPos,
+		Rparen: token.NoPos,
+	}
+	names := make([]string, 0, len(p.globals))
+	for name := range p.globals {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		global := p.globals[name]
+		obj := &ast.Object{
+			Kind: ast.Var,
+			Name: "C." + name,
+		}
+		valueSpec := &ast.ValueSpec{
+			Names: []*ast.Ident{&ast.Ident{
+				NamePos: global.pos,
+				Name:    "C." + name,
+				Obj:     obj,
+			}},
+			Type: global.typeExpr,
+		}
+		obj.Decl = valueSpec
+		gen.Specs = append(gen.Specs, valueSpec)
+	}
+	p.generated.Decls = append(p.generated.Decls, gen)
+}
+
+// addTypeAliases aliases some built-in Go types with their equivalent C types.
+// It adds code like the following to the AST:
+//
+//     type (
+//         C.int8_t  = int8
+//         C.int16_t = int16
+//         // ...
+//     )
+func (p *cgoPackage) addTypeAliases() {
+	aliasKeys := make([]string, 0, len(cgoAliases))
+	for key := range cgoAliases {
+		aliasKeys = append(aliasKeys, key)
+	}
+	sort.Strings(aliasKeys)
+	gen := &ast.GenDecl{
+		TokPos: token.NoPos,
+		Tok:    token.TYPE,
+		Lparen: token.NoPos,
+		Rparen: token.NoPos,
+	}
+	for _, typeName := range aliasKeys {
+		goTypeName := cgoAliases[typeName]
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: typeName,
+		}
+		typeSpec := &ast.TypeSpec{
+			Name: &ast.Ident{
+				NamePos: token.NoPos,
+				Name:    typeName,
+				Obj:     obj,
+			},
+			Assign: p.generatedPos,
+			Type: &ast.Ident{
+				NamePos: token.NoPos,
+				Name:    goTypeName,
+			},
+		}
+		obj.Decl = typeSpec
+		gen.Specs = append(gen.Specs, typeSpec)
+	}
+	p.generated.Decls = append(p.generated.Decls, gen)
+}
+
+func (p *cgoPackage) addTypedefs() {
+	if len(p.typedefs) == 0 {
+		return
+	}
+	gen := &ast.GenDecl{
+		TokPos: token.NoPos,
+		Tok:    token.TYPE,
+	}
+	names := make([]string, 0, len(p.typedefs))
+	for name := range p.typedefs {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		typedef := p.typedefs[name]
+		typeName := "C." + name
+		isAlias := true
+		if strings.HasPrefix(name, "_Cgo_") {
+			typeName = "C." + name[len("_Cgo_"):]
+			isAlias = false // C.short etc. should not be aliased to the equivalent Go type (not portable)
+		}
+		if _, ok := cgoAliases[typeName]; ok {
+			// This is a type that also exists in Go (defined in stdint.h).
+			continue
+		}
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: typeName,
+		}
+		typeSpec := &ast.TypeSpec{
+			Name: &ast.Ident{
+				NamePos: typedef.pos,
+				Name:    typeName,
+				Obj:     obj,
+			},
+			Type: typedef.typeExpr,
+		}
+		if isAlias {
+			typeSpec.Assign = typedef.pos
+		}
+		obj.Decl = typeSpec
+		gen.Specs = append(gen.Specs, typeSpec)
+	}
+	p.generated.Decls = append(p.generated.Decls, gen)
+}
+
+// addElaboratedTypes adds C elaborated types as aliases. These are the "struct
+// foo" or "union foo" types, often used in a typedef.
+//
+// See also:
+// https://en.cppreference.com/w/cpp/language/elaborated_type_specifier
+func (p *cgoPackage) addElaboratedTypes() {
+	if len(p.elaboratedTypes) == 0 {
+		return
+	}
+	gen := &ast.GenDecl{
+		TokPos: token.NoPos,
+		Tok:    token.TYPE,
+	}
+	names := make([]string, 0, len(p.elaboratedTypes))
+	for name := range p.elaboratedTypes {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		typ := p.elaboratedTypes[name]
+		typeName := "C." + name
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: typeName,
+		}
+		typeSpec := &ast.TypeSpec{
+			Name: &ast.Ident{
+				NamePos: typ.pos,
+				Name:    typeName,
+				Obj:     obj,
+			},
+			Type: typ.typeExpr,
+		}
+		obj.Decl = typeSpec
+		gen.Specs = append(gen.Specs, typeSpec)
+	}
+	p.generated.Decls = append(p.generated.Decls, gen)
+}
+
+// addEnumTypes adds C enums to the AST. For example, the following C code:
+//
+//     enum option {
+//         optionA,
+//         optionB = 5,
+//     };
+//
+// is translated to the following Go code equivalent:
+//
+//     type C.enum_option int32
+//
+// The constants are treated just like macros so are inserted into the AST by
+// addConstDecls.
+// See also: https://en.cppreference.com/w/c/language/enum
+func (p *cgoPackage) addEnumTypes() {
+	if len(p.enums) == 0 {
+		return
+	}
+	gen := &ast.GenDecl{
+		TokPos: token.NoPos,
+		Tok:    token.TYPE,
+	}
+	names := make([]string, 0, len(p.enums))
+	for name := range p.enums {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		typ := p.enums[name]
+		typeName := "C.enum_" + name
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: typeName,
+		}
+		typeSpec := &ast.TypeSpec{
+			Name: &ast.Ident{
+				NamePos: typ.pos,
+				Name:    typeName,
+				Obj:     obj,
+			},
+			Type: typ.typeExpr,
+		}
+		obj.Decl = typeSpec
+		gen.Specs = append(gen.Specs, typeSpec)
+	}
+	p.generated.Decls = append(p.generated.Decls, gen)
+}
+
+// findMissingCGoNames traverses the AST and finds all C.something names. Only
+// these symbols are extracted from the parsed C AST and converted to the Go
+// equivalent.
+func (p *cgoPackage) findMissingCGoNames(cursor *astutil.Cursor) bool {
+	switch node := cursor.Node().(type) {
+	case *ast.SelectorExpr:
+		x, ok := node.X.(*ast.Ident)
+		if !ok {
+			return true
+		}
+		if x.Name == "C" {
+			name := node.Sel.Name
+			if _, ok := builtinAliases[name]; ok {
+				name = "_Cgo_" + name
+			}
+			p.missingSymbols[name] = struct{}{}
+		}
+	}
+	return true
+}
+
+// walker replaces all "C".<something> expressions to literal "C.<something>"
+// expressions. Such expressions are impossible to write in Go (a dot cannot be
+// used in the middle of a name) so in practice all C identifiers live in a
+// separate namespace (no _Cgo_ hacks like in gc).
+func (p *cgoPackage) walker(cursor *astutil.Cursor) bool {
+	switch node := cursor.Node().(type) {
+	case *ast.CallExpr:
+		fun, ok := node.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+		x, ok := fun.X.(*ast.Ident)
+		if !ok {
+			return true
+		}
+		if _, ok := p.functions[fun.Sel.Name]; ok && x.Name == "C" {
+			node.Fun = &ast.Ident{
+				NamePos: x.NamePos,
+				Name:    "C." + fun.Sel.Name,
+			}
+		}
+	case *ast.SelectorExpr:
+		x, ok := node.X.(*ast.Ident)
+		if !ok {
+			return true
+		}
+		if x.Name == "C" {
+			name := "C." + node.Sel.Name
+			if _, ok := p.functions[node.Sel.Name]; ok {
+				name += "$funcaddr"
+			}
+			cursor.Replace(&ast.Ident{
+				NamePos: x.NamePos,
+				Name:    name,
+			})
+		}
+	}
+	return true
+}

cgo/libclang.go

@@ -0,0 +1,674 @@
+package cgo
+
+// This file parses a fragment of C with libclang and stores the result for AST
+// modification. It does not touch the AST itself.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/scanner"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"unsafe"
+)
+
+/*
+#include <clang-c/Index.h> // if this fails, install libclang-8-dev
+#include <stdlib.h>
+#include <stdint.h>
+
+// This struct should be ABI-compatible on all platforms (uintptr_t has the same
+// alignment etc. as void*) but does not include void* pointers that are not
+// always real pointers.
+// The Go garbage collector assumes that all non-nil pointer-typed integers are
+// actually pointers. This is not always true, as data[1] often contains 0x1,
+// which is clearly not a valid pointer. Usually the GC won't catch this issue,
+// but occasionally it will leading to a crash with a vague error message.
+typedef struct {
+	enum CXCursorKind kind;
+	int xdata;
+	uintptr_t data[3];
+} GoCXCursor;
+
+// Forwarding functions. They are implemented in libclang_stubs.c and forward to
+// the real functions without doing anything else, thus they are entirely
+// compatible with the versions without tinygo_ prefix. The only difference is
+// the CXCursor type, which has been replaced with GoCXCursor.
+GoCXCursor tinygo_clang_getTranslationUnitCursor(CXTranslationUnit tu);
+unsigned tinygo_clang_visitChildren(GoCXCursor parent, CXCursorVisitor visitor, CXClientData client_data);
+CXString tinygo_clang_getCursorSpelling(GoCXCursor c);
+enum CXCursorKind tinygo_clang_getCursorKind(GoCXCursor c);
+CXType tinygo_clang_getCursorType(GoCXCursor c);
+GoCXCursor tinygo_clang_getTypeDeclaration(CXType t);
+CXType tinygo_clang_getTypedefDeclUnderlyingType(GoCXCursor c);
+CXType tinygo_clang_getCursorResultType(GoCXCursor c);
+int tinygo_clang_Cursor_getNumArguments(GoCXCursor c);
+GoCXCursor tinygo_clang_Cursor_getArgument(GoCXCursor c, unsigned i);
+CXSourceLocation tinygo_clang_getCursorLocation(GoCXCursor c);
+CXSourceRange tinygo_clang_getCursorExtent(GoCXCursor c);
+CXTranslationUnit tinygo_clang_Cursor_getTranslationUnit(GoCXCursor c);
+long long tinygo_clang_getEnumConstantDeclValue(GoCXCursor c);
+CXType tinygo_clang_getEnumDeclIntegerType(GoCXCursor c);
+
+int tinygo_clang_globals_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
+int tinygo_clang_struct_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
+int tinygo_clang_enum_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
+*/
+import "C"
+
+// storedRefs stores references to types, used for clang_visitChildren.
+var storedRefs refMap
+
+var diagnosticSeverity = [...]string{
+	C.CXDiagnostic_Ignored: "ignored",
+	C.CXDiagnostic_Note:    "note",
+	C.CXDiagnostic_Warning: "warning",
+	C.CXDiagnostic_Error:   "error",
+	C.CXDiagnostic_Fatal:   "fatal",
+}
+
+func (p *cgoPackage) parseFragment(fragment string, cflags []string, posFilename string, posLine int) {
+	index := C.clang_createIndex(0, 0)
+	defer C.clang_disposeIndex(index)
+
+	// pretend to be a .c file
+	filenameC := C.CString(posFilename + "!cgo.c")
+	defer C.free(unsafe.Pointer(filenameC))
+
+	// fix up error locations
+	fragment = fmt.Sprintf("# %d %#v\n", posLine+1, posFilename) + fragment
+
+	fragmentC := C.CString(fragment)
+	defer C.free(unsafe.Pointer(fragmentC))
+
+	unsavedFile := C.struct_CXUnsavedFile{
+		Filename: filenameC,
+		Length:   C.ulong(len(fragment)),
+		Contents: fragmentC,
+	}
+
+	// convert Go slice of strings to C array of strings.
+	cmdargsC := C.malloc(C.size_t(len(cflags)) * C.size_t(unsafe.Sizeof(uintptr(0))))
+	defer C.free(cmdargsC)
+	cmdargs := (*[1 << 16]*C.char)(cmdargsC)
+	for i, cflag := range cflags {
+		s := C.CString(cflag)
+		cmdargs[i] = s
+		defer C.free(unsafe.Pointer(s))
+	}
+
+	var unit C.CXTranslationUnit
+	errCode := C.clang_parseTranslationUnit2(
+		index,
+		filenameC,
+		(**C.char)(cmdargsC), C.int(len(cflags)), // command line args
+		&unsavedFile, 1, // unsaved files
+		C.CXTranslationUnit_DetailedPreprocessingRecord,
+		&unit)
+	if errCode != 0 {
+		panic("loader: failed to parse source with libclang")
+	}
+	defer C.clang_disposeTranslationUnit(unit)
+
+	if numDiagnostics := int(C.clang_getNumDiagnostics(unit)); numDiagnostics != 0 {
+		addDiagnostic := func(diagnostic C.CXDiagnostic) {
+			spelling := getString(C.clang_getDiagnosticSpelling(diagnostic))
+			severity := diagnosticSeverity[C.clang_getDiagnosticSeverity(diagnostic)]
+			location := C.clang_getDiagnosticLocation(diagnostic)
+			var libclangFilename C.CXString
+			var line C.unsigned
+			var column C.unsigned
+			C.clang_getPresumedLocation(location, &libclangFilename, &line, &column)
+			filename := getString(libclangFilename)
+			if filepath.IsAbs(filename) {
+				// Relative paths for readability, like other Go parser errors.
+				relpath, err := filepath.Rel(p.dir, filename)
+				if err == nil {
+					filename = relpath
+				}
+			}
+			p.errors = append(p.errors, &scanner.Error{
+				Pos: token.Position{
+					Filename: filename,
+					Offset:   0, // not provided by clang_getPresumedLocation
+					Line:     int(line),
+					Column:   int(column),
+				},
+				Msg: severity + ": " + spelling,
+			})
+		}
+		for i := 0; i < numDiagnostics; i++ {
+			diagnostic := C.clang_getDiagnostic(unit, C.uint(i))
+			addDiagnostic(diagnostic)
+
+			// Child diagnostics (like notes on redefinitions).
+			diagnostics := C.clang_getChildDiagnostics(diagnostic)
+			for j := 0; j < int(C.clang_getNumDiagnosticsInSet(diagnostics)); j++ {
+				addDiagnostic(C.clang_getDiagnosticInSet(diagnostics, C.uint(j)))
+			}
+		}
+		return
+	}
+
+	ref := storedRefs.Put(p)
+	defer storedRefs.Remove(ref)
+	cursor := C.tinygo_clang_getTranslationUnitCursor(unit)
+	C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_globals_visitor), C.CXClientData(ref))
+}
+
+//export tinygo_clang_globals_visitor
+func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClientData) C.int {
+	p := storedRefs.Get(unsafe.Pointer(client_data)).(*cgoPackage)
+	kind := C.tinygo_clang_getCursorKind(c)
+	pos := p.getCursorPosition(c)
+	switch kind {
+	case C.CXCursor_FunctionDecl:
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if _, required := p.missingSymbols[name]; !required {
+			return C.CXChildVisit_Continue
+		}
+		cursorType := C.tinygo_clang_getCursorType(c)
+		if C.clang_isFunctionTypeVariadic(cursorType) != 0 {
+			return C.CXChildVisit_Continue // not supported
+		}
+		numArgs := int(C.tinygo_clang_Cursor_getNumArguments(c))
+		fn := &functionInfo{
+			pos: pos,
+		}
+		p.functions[name] = fn
+		for i := 0; i < numArgs; i++ {
+			arg := C.tinygo_clang_Cursor_getArgument(c, C.uint(i))
+			argName := getString(C.tinygo_clang_getCursorSpelling(arg))
+			argType := C.clang_getArgType(cursorType, C.uint(i))
+			if argName == "" {
+				argName = "$" + strconv.Itoa(i)
+			}
+			fn.args = append(fn.args, paramInfo{
+				name:     argName,
+				typeExpr: p.makeASTType(argType, pos),
+			})
+		}
+		resultType := C.tinygo_clang_getCursorResultType(c)
+		if resultType.kind != C.CXType_Void {
+			fn.results = &ast.FieldList{
+				List: []*ast.Field{
+					&ast.Field{
+						Type: p.makeASTType(resultType, pos),
+					},
+				},
+			}
+		}
+	case C.CXCursor_StructDecl:
+		typ := C.tinygo_clang_getCursorType(c)
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if _, required := p.missingSymbols["struct_"+name]; !required {
+			return C.CXChildVisit_Continue
+		}
+		p.makeASTType(typ, pos)
+	case C.CXCursor_TypedefDecl:
+		typedefType := C.tinygo_clang_getCursorType(c)
+		name := getString(C.clang_getTypedefName(typedefType))
+		if _, required := p.missingSymbols[name]; !required {
+			return C.CXChildVisit_Continue
+		}
+		p.makeASTType(typedefType, pos)
+	case C.CXCursor_VarDecl:
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if _, required := p.missingSymbols[name]; !required {
+			return C.CXChildVisit_Continue
+		}
+		cursorType := C.tinygo_clang_getCursorType(c)
+		p.globals[name] = globalInfo{
+			typeExpr: p.makeASTType(cursorType, pos),
+			pos:      pos,
+		}
+	case C.CXCursor_MacroDefinition:
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if _, required := p.missingSymbols[name]; !required {
+			return C.CXChildVisit_Continue
+		}
+		sourceRange := C.tinygo_clang_getCursorExtent(c)
+		start := C.clang_getRangeStart(sourceRange)
+		end := C.clang_getRangeEnd(sourceRange)
+		var file, endFile C.CXFile
+		var startOffset, endOffset C.unsigned
+		C.clang_getExpansionLocation(start, &file, nil, nil, &startOffset)
+		if file == nil {
+			panic("could not find file where macro is defined")
+		}
+		C.clang_getExpansionLocation(end, &endFile, nil, nil, &endOffset)
+		if file != endFile {
+			panic("expected start and end location of a #define to be in the same file")
+		}
+		if startOffset > endOffset {
+			panic("startOffset > endOffset")
+		}
+
+		// read file contents and extract the relevant byte range
+		tu := C.tinygo_clang_Cursor_getTranslationUnit(c)
+		var size C.size_t
+		sourcePtr := C.clang_getFileContents(tu, file, &size)
+		if endOffset >= C.uint(size) {
+			panic("endOffset lies after end of file")
+		}
+		source := string(((*[1 << 28]byte)(unsafe.Pointer(sourcePtr)))[startOffset:endOffset:endOffset])
+		if !strings.HasPrefix(source, name) {
+			panic(fmt.Sprintf("expected #define value to start with %#v, got %#v", name, source))
+		}
+		value := strings.TrimSpace(source[len(name):])
+		for len(value) != 0 && value[0] == '(' && value[len(value)-1] == ')' {
+			value = strings.TrimSpace(value[1 : len(value)-1])
+		}
+		if len(value) == 0 {
+			// Pretend it doesn't exist at all.
+			return C.CXChildVisit_Continue
+		}
+		// For information about integer literals:
+		// https://en.cppreference.com/w/cpp/language/integer_literal
+		if value[0] == '"' {
+			// string constant
+			p.constants[name] = constantInfo{&ast.BasicLit{pos, token.STRING, value}, pos}
+			return C.CXChildVisit_Continue
+		}
+		if value[0] == '\'' {
+			// char constant
+			p.constants[name] = constantInfo{&ast.BasicLit{pos, token.CHAR, value}, pos}
+			return C.CXChildVisit_Continue
+		}
+		// assume it's a number (int or float)
+		value = strings.Replace(value, "'", "", -1) // remove ' chars
+		value = strings.TrimRight(value, "lu")      // remove llu suffixes etc.
+		// find the first non-number
+		nonnum := byte(0)
+		for i := 0; i < len(value); i++ {
+			if value[i] < '0' || value[i] > '9' {
+				nonnum = value[i]
+				break
+			}
+		}
+		// determine number type based on the first non-number
+		switch nonnum {
+		case 0:
+			// no non-number found, must be an integer
+			p.constants[name] = constantInfo{&ast.BasicLit{pos, token.INT, value}, pos}
+		case 'x', 'X':
+			// hex integer constant
+			// TODO: may also be a floating point number per C++17.
+			p.constants[name] = constantInfo{&ast.BasicLit{pos, token.INT, value}, pos}
+		case '.', 'e':
+			// float constant
+			value = strings.TrimRight(value, "fFlL")
+			p.constants[name] = constantInfo{&ast.BasicLit{pos, token.FLOAT, value}, pos}
+		default:
+			// unknown type, ignore
+		}
+	}
+	return C.CXChildVisit_Continue
+}
+
+func getString(clangString C.CXString) (s string) {
+	rawString := C.clang_getCString(clangString)
+	s = C.GoString(rawString)
+	C.clang_disposeString(clangString)
+	return
+}
+
+// getCursorPosition returns a usable token.Pos from a libclang cursor. If the
+// file for this cursor has not been seen before, it is read from libclang
+// (which already has the file in memory) and added to the token.FileSet.
+func (p *cgoPackage) getCursorPosition(cursor C.GoCXCursor) token.Pos {
+	location := C.tinygo_clang_getCursorLocation(cursor)
+	var file C.CXFile
+	var line C.unsigned
+	var column C.unsigned
+	var offset C.unsigned
+	C.clang_getExpansionLocation(location, &file, &line, &column, &offset)
+	if line == 0 || file == nil {
+		// Invalid token.
+		return token.NoPos
+	}
+	filename := getString(C.clang_getFileName(file))
+	if _, ok := p.tokenFiles[filename]; !ok {
+		// File has not been seen before in this package, add line information
+		// now by reading the file from libclang.
+		tu := C.tinygo_clang_Cursor_getTranslationUnit(cursor)
+		var size C.size_t
+		sourcePtr := C.clang_getFileContents(tu, file, &size)
+		source := ((*[1 << 28]byte)(unsafe.Pointer(sourcePtr)))[:size:size]
+		lines := []int{0}
+		for i := 0; i < len(source)-1; i++ {
+			if source[i] == '\n' {
+				lines = append(lines, i+1)
+			}
+		}
+		f := p.fset.AddFile(filename, -1, int(size))
+		f.SetLines(lines)
+		p.tokenFiles[filename] = f
+	}
+	return p.tokenFiles[filename].Pos(int(offset))
+}
+
+// makeASTType return the ast.Expr for the given libclang type. In other words,
+// it converts a libclang type to a type in the Go AST.
+func (p *cgoPackage) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
+	var typeName string
+	switch typ.kind {
+	case C.CXType_Char_S, C.CXType_Char_U:
+		typeName = "C.char"
+	case C.CXType_SChar:
+		typeName = "C.schar"
+	case C.CXType_UChar:
+		typeName = "C.uchar"
+	case C.CXType_Short:
+		typeName = "C.short"
+	case C.CXType_UShort:
+		typeName = "C.ushort"
+	case C.CXType_Int:
+		typeName = "C.int"
+	case C.CXType_UInt:
+		typeName = "C.uint"
+	case C.CXType_Long:
+		typeName = "C.long"
+	case C.CXType_ULong:
+		typeName = "C.ulong"
+	case C.CXType_LongLong:
+		typeName = "C.longlong"
+	case C.CXType_ULongLong:
+		typeName = "C.ulonglong"
+	case C.CXType_Bool:
+		typeName = "bool"
+	case C.CXType_Float, C.CXType_Double, C.CXType_LongDouble:
+		switch C.clang_Type_getSizeOf(typ) {
+		case 4:
+			typeName = "float32"
+		case 8:
+			typeName = "float64"
+		default:
+			// Don't do anything, rely on the fallback code to show a somewhat
+			// sensible error message like "undeclared name: C.long double".
+		}
+	case C.CXType_Complex:
+		switch C.clang_Type_getSizeOf(typ) {
+		case 8:
+			typeName = "complex64"
+		case 16:
+			typeName = "complex128"
+		}
+	case C.CXType_Pointer:
+		pointeeType := C.clang_getPointeeType(typ)
+		if pointeeType.kind == C.CXType_Void {
+			// void* type is translated to Go as unsafe.Pointer
+			return &ast.SelectorExpr{
+				X: &ast.Ident{
+					NamePos: pos,
+					Name:    "unsafe",
+				},
+				Sel: &ast.Ident{
+					NamePos: pos,
+					Name:    "Pointer",
+				},
+			}
+		}
+		return &ast.StarExpr{
+			Star: pos,
+			X:    p.makeASTType(pointeeType, pos),
+		}
+	case C.CXType_ConstantArray:
+		return &ast.ArrayType{
+			Lbrack: pos,
+			Len: &ast.BasicLit{
+				ValuePos: pos,
+				Kind:     token.INT,
+				Value:    strconv.FormatInt(int64(C.clang_getArraySize(typ)), 10),
+			},
+			Elt: p.makeASTType(C.clang_getElementType(typ), pos),
+		}
+	case C.CXType_FunctionProto:
+		// Be compatible with gc, which uses the *[0]byte type for function
+		// pointer types.
+		// Return type [0]byte because this is a function type, not a pointer to
+		// this function type.
+		return &ast.ArrayType{
+			Lbrack: pos,
+			Len: &ast.BasicLit{
+				ValuePos: pos,
+				Kind:     token.INT,
+				Value:    "0",
+			},
+			Elt: &ast.Ident{
+				NamePos: pos,
+				Name:    "byte",
+			},
+		}
+	case C.CXType_Typedef:
+		name := getString(C.clang_getTypedefName(typ))
+		if _, ok := p.typedefs[name]; !ok {
+			p.typedefs[name] = nil // don't recurse
+			c := C.tinygo_clang_getTypeDeclaration(typ)
+			underlyingType := C.tinygo_clang_getTypedefDeclUnderlyingType(c)
+			expr := p.makeASTType(underlyingType, pos)
+			if strings.HasPrefix(name, "_Cgo_") {
+				expr := expr.(*ast.Ident)
+				typeSize := C.clang_Type_getSizeOf(underlyingType)
+				switch expr.Name {
+				case "C.char":
+					if typeSize != 1 {
+						// This happens for some very special purpose architectures
+						// (DSPs etc.) that are not currently targeted.
+						// https://www.embecosm.com/2017/04/18/non-8-bit-char-support-in-clang-and-llvm/
+						panic("unknown char width")
+					}
+					switch underlyingType.kind {
+					case C.CXType_Char_S:
+						expr.Name = "int8"
+					case C.CXType_Char_U:
+						expr.Name = "uint8"
+					}
+				case "C.schar", "C.short", "C.int", "C.long", "C.longlong":
+					switch typeSize {
+					case 1:
+						expr.Name = "int8"
+					case 2:
+						expr.Name = "int16"
+					case 4:
+						expr.Name = "int32"
+					case 8:
+						expr.Name = "int64"
+					}
+				case "C.uchar", "C.ushort", "C.uint", "C.ulong", "C.ulonglong":
+					switch typeSize {
+					case 1:
+						expr.Name = "uint8"
+					case 2:
+						expr.Name = "uint16"
+					case 4:
+						expr.Name = "uint32"
+					case 8:
+						expr.Name = "uint64"
+					}
+				}
+			}
+			p.typedefs[name] = &typedefInfo{
+				typeExpr: expr,
+				pos:      pos,
+			}
+		}
+		return &ast.Ident{
+			NamePos: pos,
+			Name:    "C." + name,
+		}
+	case C.CXType_Elaborated:
+		underlying := C.clang_Type_getNamedType(typ)
+		switch underlying.kind {
+		case C.CXType_Record:
+			return p.makeASTType(underlying, pos)
+		case C.CXType_Enum:
+			return p.makeASTType(underlying, pos)
+		default:
+			panic("unknown elaborated type")
+		}
+	case C.CXType_Record:
+		cursor := C.tinygo_clang_getTypeDeclaration(typ)
+		name := getString(C.tinygo_clang_getCursorSpelling(cursor))
+		var cgoName string
+		switch C.tinygo_clang_getCursorKind(cursor) {
+		case C.CXCursor_StructDecl:
+			cgoName = "struct_" + name
+		case C.CXCursor_UnionDecl:
+			cgoName = "union_" + name
+		default:
+			panic("unknown record declaration")
+		}
+		if _, ok := p.elaboratedTypes[cgoName]; !ok {
+			p.elaboratedTypes[cgoName] = nil // predeclare (to avoid endless recursion)
+			fieldList := &ast.FieldList{
+				Opening: pos,
+				Closing: pos,
+			}
+			ref := storedRefs.Put(struct {
+				fieldList *ast.FieldList
+				pkg       *cgoPackage
+			}{fieldList, p})
+			defer storedRefs.Remove(ref)
+			C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_struct_visitor), C.CXClientData(ref))
+			switch C.tinygo_clang_getCursorKind(cursor) {
+			case C.CXCursor_StructDecl:
+				p.elaboratedTypes[cgoName] = &elaboratedTypeInfo{
+					typeExpr: &ast.StructType{
+						Struct: pos,
+						Fields: fieldList,
+					},
+					pos: pos,
+				}
+			case C.CXCursor_UnionDecl:
+				if len(fieldList.List) > 1 {
+					// Insert a special field at the front (of zero width) as a
+					// marker that this is struct is actually a union. This is done
+					// by giving the field a name that cannot be expressed directly
+					// in Go.
+					// Other parts of the compiler look at the first element in a
+					// struct (of size > 2) to know whether this is a union.
+					// Note that we don't have to insert it for single-element
+					// unions as they're basically equivalent to a struct.
+					unionMarker := &ast.Field{
+						Type: &ast.StructType{
+							Struct: pos,
+						},
+					}
+					unionMarker.Names = []*ast.Ident{
+						&ast.Ident{
+							NamePos: pos,
+							Name:    "C union",
+							Obj: &ast.Object{
+								Kind: ast.Var,
+								Name: "C union",
+								Decl: unionMarker,
+							},
+						},
+					}
+					fieldList.List = append([]*ast.Field{unionMarker}, fieldList.List...)
+				}
+				p.elaboratedTypes[cgoName] = &elaboratedTypeInfo{
+					typeExpr: &ast.StructType{
+						Struct: pos,
+						Fields: fieldList,
+					},
+					pos: pos,
+				}
+			default:
+				panic("unreachable")
+			}
+		}
+		return &ast.Ident{
+			NamePos: pos,
+			Name:    "C." + cgoName,
+		}
+	case C.CXType_Enum:
+		cursor := C.tinygo_clang_getTypeDeclaration(typ)
+		name := getString(C.tinygo_clang_getCursorSpelling(cursor))
+		underlying := C.tinygo_clang_getEnumDeclIntegerType(cursor)
+		if name == "" {
+			// anonymous enum
+			ref := storedRefs.Put(p)
+			defer storedRefs.Remove(ref)
+			C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_enum_visitor), C.CXClientData(ref))
+			return p.makeASTType(underlying, pos)
+		} else {
+			// named enum
+			if _, ok := p.enums[name]; !ok {
+				ref := storedRefs.Put(p)
+				defer storedRefs.Remove(ref)
+				C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_enum_visitor), C.CXClientData(ref))
+				p.enums[name] = enumInfo{
+					typeExpr: p.makeASTType(underlying, pos),
+					pos:      pos,
+				}
+			}
+			return &ast.Ident{
+				NamePos: pos,
+				Name:    "C.enum_" + name,
+			}
+		}
+	}
+	if typeName == "" {
+		// Report this as an error.
+		spelling := getString(C.clang_getTypeSpelling(typ))
+		p.errors = append(p.errors, scanner.Error{
+			Pos: p.fset.PositionFor(pos, true),
+			Msg: fmt.Sprintf("unknown C type: %v (libclang type kind %d)", spelling, typ.kind),
+		})
+		// Fallback, probably incorrect but at least the error points to an odd
+		// type name.
+		typeName = "C." + spelling
+	}
+	return &ast.Ident{
+		NamePos: pos,
+		Name:    typeName,
+	}
+}
+
+//export tinygo_clang_struct_visitor
+func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientData) C.int {
+	passed := storedRefs.Get(unsafe.Pointer(client_data)).(struct {
+		fieldList *ast.FieldList
+		pkg       *cgoPackage
+	})
+	fieldList := passed.fieldList
+	p := passed.pkg
+	if C.tinygo_clang_getCursorKind(c) != C.CXCursor_FieldDecl {
+		panic("expected field inside cursor")
+	}
+	name := getString(C.tinygo_clang_getCursorSpelling(c))
+	typ := C.tinygo_clang_getCursorType(c)
+	field := &ast.Field{
+		Type: p.makeASTType(typ, p.getCursorPosition(c)),
+	}
+	field.Names = []*ast.Ident{
+		&ast.Ident{
+			NamePos: p.getCursorPosition(c),
+			Name:    name,
+			Obj: &ast.Object{
+				Kind: ast.Var,
+				Name: name,
+				Decl: field,
+			},
+		},
+	}
+	fieldList.List = append(fieldList.List, field)
+	return C.CXChildVisit_Continue
+}
+
+//export tinygo_clang_enum_visitor
+func tinygo_clang_enum_visitor(c, parent C.GoCXCursor, client_data C.CXClientData) C.int {
+	p := storedRefs.Get(unsafe.Pointer(client_data)).(*cgoPackage)
+	name := getString(C.tinygo_clang_getCursorSpelling(c))
+	pos := p.getCursorPosition(c)
+	value := C.tinygo_clang_getEnumConstantDeclValue(c)
+	p.constants[name] = constantInfo{
+		expr: &ast.BasicLit{pos, token.INT, strconv.FormatInt(int64(value), 10)},
+		pos:  pos,
+	}
+	return C.CXChildVisit_Continue
+}

cgo/libclang_config.go

@@ -1,6 +1,6 @@
 // +build !byollvm
 
-package loader
+package cgo
 
 /*
 #cgo linux  CFLAGS: -I/usr/lib/llvm-8/include

cgo/libclang_stubs.c

@@ -44,3 +44,23 @@ int tinygo_clang_Cursor_getNumArguments(CXCursor c) {
 CXCursor tinygo_clang_Cursor_getArgument(CXCursor c, unsigned i) {
 	return clang_Cursor_getArgument(c, i);
 }
+
+CXSourceLocation tinygo_clang_getCursorLocation(CXCursor c) {
+	return clang_getCursorLocation(c);
+}
+
+CXSourceRange tinygo_clang_getCursorExtent(CXCursor c) {
+	return clang_getCursorExtent(c);
+}
+
+CXTranslationUnit tinygo_clang_Cursor_getTranslationUnit(CXCursor c) {
+	return clang_Cursor_getTranslationUnit(c);
+}
+
+long long tinygo_clang_getEnumConstantDeclValue(CXCursor c) {
+	return clang_getEnumConstantDeclValue(c);
+}
+
+CXType tinygo_clang_getEnumDeclIntegerType(CXCursor c) {
+	return clang_getEnumDeclIntegerType(c);
+}

cgo/sync.go

@@ -1,4 +1,4 @@
-package loader
+package cgo
 
 import (
 	"sync"
@@ -8,17 +8,17 @@ import (
 // #include <stdlib.h>
 import "C"
 
-// RefMap is a convenient way to store opaque references that can be passed to
+// refMap is a convenient way to store opaque references that can be passed to
 // C. It is useful if an API uses function pointers and you cannot pass a Go
 // pointer but only a C pointer.
-type RefMap struct {
+type refMap struct {
 	refs map[unsafe.Pointer]interface{}
 	lock sync.Mutex
 }
 
 // Put stores a value in the map. It can later be retrieved using Get. It must
 // be removed using Remove to avoid memory leaks.
-func (m *RefMap) Put(v interface{}) unsafe.Pointer {
+func (m *refMap) Put(v interface{}) unsafe.Pointer {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 	if m.refs == nil {
@@ -31,14 +31,14 @@ func (m *RefMap) Put(v interface{}) unsafe.Pointer {
 
 // Get returns a stored value previously inserted with Put. Use the same
 // reference as you got from Put.
-func (m *RefMap) Get(ref unsafe.Pointer) interface{} {
+func (m *refMap) Get(ref unsafe.Pointer) interface{} {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 	return m.refs[ref]
 }
 
 // Remove deletes a single reference from the map.
-func (m *RefMap) Remove(ref unsafe.Pointer) {
+func (m *refMap) Remove(ref unsafe.Pointer) {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 	delete(m.refs, ref)

commands.go

@@ -1,10 +1,44 @@
-// +build !darwin
-
 package main
 
-// commands used by the compilation process might have different file names on Linux than those used on macOS.
-var commands = map[string]string{
-	"clang":   "clang-8",
-	"ld.lld":  "ld.lld-8",
-	"wasm-ld": "wasm-ld-8",
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+)
+
+// Commands used by the compilation process might have different file names
+// across operating systems and distributions.
+var commands = map[string][]string{
+	"clang":   {"clang-8"},
+	"ld.lld":  {"ld.lld-8", "ld.lld"},
+	"wasm-ld": {"wasm-ld-8", "wasm-ld"},
+}
+
+func init() {
+	// Add the path to a Homebrew-installed LLVM 8 for ease of use (no need to
+	// manually set $PATH).
+	if runtime.GOOS == "darwin" {
+		commands["clang"] = append(commands["clang"], "/usr/local/opt/llvm/bin/clang-8")
+		commands["ld.lld"] = append(commands["ld.lld"], "/usr/local/opt/llvm/bin/ld.lld")
+		commands["wasm-ld"] = append(commands["wasm-ld"], "/usr/local/opt/llvm/bin/wasm-ld")
+	}
+}
+
+func execCommand(cmdNames []string, args ...string) error {
+	for _, cmdName := range cmdNames {
+		cmd := exec.Command(cmdName, args...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err := cmd.Run()
+		if err != nil {
+			if err, ok := err.(*exec.Error); ok && err.Err == exec.ErrNotFound {
+				// this command was not found, try the next
+				continue
+			}
+		}
+		return nil
+	}
+	return errors.New("none of these commands were found in your $PATH: " + strings.Join(cmdNames, " "))
 }

commands_macos.go

@@ -1,10 +0,0 @@
-// +build darwin
-
-package main
-
-// commands used by the compilation process might have different file names on macOS than those used on Linux.
-var commands = map[string]string{
-	"clang":   "clang-8",
-	"ld.lld":  "ld.lld",
-	"wasm-ld": "wasm-ld",
-}

compiler/asserts.go

@@ -42,7 +42,7 @@ func (c *Compiler) emitLookupBoundsCheck(frame *Frame, arrayLen, index llvm.Valu
 
 	// Fail: this is a nil pointer, exit with a panic.
 	c.builder.SetInsertPointAtEnd(faultBlock)
-	c.createRuntimeCall("lookuppanic", nil, "")
+	c.createRuntimeCall("lookupPanic", nil, "")
 	c.builder.CreateUnreachable()
 
 	// Ok: this is a valid pointer.
@@ -103,7 +103,7 @@ func (c *Compiler) emitSliceBoundsCheck(frame *Frame, capacity, low, high llvm.V
 
 	// Fail: this is a nil pointer, exit with a panic.
 	c.builder.SetInsertPointAtEnd(faultBlock)
-	c.createRuntimeCall("slicepanic", nil, "")
+	c.createRuntimeCall("slicePanic", nil, "")
 	c.builder.CreateUnreachable()
 
 	// Ok: this is a valid pointer.
@@ -114,6 +114,11 @@ func (c *Compiler) emitSliceBoundsCheck(frame *Frame, capacity, low, high llvm.V
 // has no effect in well-behaved programs, but makes sure no uncaught nil
 // pointer dereferences exist in valid Go code.
 func (c *Compiler) emitNilCheck(frame *Frame, ptr llvm.Value, blockPrefix string) {
+	// Check whether we need to emit this check at all.
+	if !ptr.IsAGlobalValue().IsNil() {
+		return
+	}
+
 	// Check whether this is a nil pointer.
 	faultBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, blockPrefix+".nil")
 	nextBlock := c.ctx.AddBasicBlock(frame.fn.LLVMFn, blockPrefix+".next")
@@ -141,7 +146,7 @@ func (c *Compiler) emitNilCheck(frame *Frame, ptr llvm.Value, blockPrefix string
 
 	// Fail: this is a nil pointer, exit with a panic.
 	c.builder.SetInsertPointAtEnd(faultBlock)
-	c.createRuntimeCall("nilpanic", nil, "")
+	c.createRuntimeCall("nilPanic", nil, "")
 	c.builder.CreateUnreachable()
 
 	// Ok: this is a valid pointer.

compiler/calls.go

@@ -55,6 +55,25 @@ func (c *Compiler) expandFormalParamType(t llvm.Type) []llvm.Type {
 	}
 }
 
+// Expand an argument type to a list of offsets from the start of the object.
+// Used together with expandFormalParam to get the offset of each value from the
+// start of the non-expanded value.
+func (c *Compiler) expandFormalParamOffsets(t llvm.Type) []uint64 {
+	switch t.TypeKind() {
+	case llvm.StructTypeKind:
+		fields := c.flattenAggregateTypeOffsets(t)
+		if len(fields) <= MaxFieldsPerParam {
+			return fields
+		} else {
+			// failed to lower
+			return []uint64{0}
+		}
+	default:
+		// TODO: split small arrays
+		return []uint64{0}
+	}
+}
+
 // Equivalent of expandFormalParamType for parameter values.
 func (c *Compiler) expandFormalParam(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
@@ -92,6 +111,27 @@ func (c *Compiler) flattenAggregateType(t llvm.Type) []llvm.Type {
 	}
 }
 
+// Return the offsets from the start of the object if this object type were
+// flattened like in flattenAggregate. Used together with flattenAggregate to
+// know the start indices of each value in the non-flattened object.
+func (c *Compiler) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
+	switch t.TypeKind() {
+	case llvm.StructTypeKind:
+		fields := make([]uint64, 0, t.StructElementTypesCount())
+		for fieldIndex, field := range t.StructElementTypes() {
+			suboffsets := c.flattenAggregateTypeOffsets(field)
+			offset := c.targetData.ElementOffset(t, fieldIndex)
+			for i := range suboffsets {
+				suboffsets[i] += offset
+			}
+			fields = append(fields, suboffsets...)
+		}
+		return fields
+	default:
+		return []uint64{0}
+	}
+}
+
 // Break down a struct into its elementary types for argument passing. The value
 // equivalent of flattenAggregateType
 func (c *Compiler) flattenAggregate(v llvm.Value) []llvm.Value {
@@ -123,10 +163,7 @@ func (c *Compiler) collapseFormalParamInternal(t llvm.Type, fields []llvm.Value)
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
 		if len(c.flattenAggregateType(t)) <= MaxFieldsPerParam {
-			value, err := c.getZeroValue(t)
-			if err != nil {
-				panic("could not get zero value of struct: " + err.Error())
-			}
+			value := c.getZeroValue(t)
 			for i, subtyp := range t.StructElementTypes() {
 				structField, remaining := c.collapseFormalParamInternal(subtyp, fields)
 				fields = remaining

compiler/channel.go

@@ -12,16 +12,6 @@ import (
 
 // emitMakeChan returns a new channel value for the given channel type.
 func (c *Compiler) emitMakeChan(expr *ssa.MakeChan) (llvm.Value, error) {
-	valueType, err := c.getLLVMType(expr.Type().(*types.Chan).Elem())
-	if err != nil {
-		return llvm.Value{}, err
-	}
-	if c.targetData.TypeAllocSize(valueType) > c.targetData.TypeAllocSize(c.intType) {
-		// Values bigger than int overflow the data part of the coroutine.
-		// TODO: make the coroutine data part big enough to hold these bigger
-		// values.
-		return llvm.Value{}, c.makeError(expr.Pos(), "todo: channel with values bigger than int")
-	}
 	chanType := c.mod.GetTypeByName("runtime.channel")
 	size := c.targetData.TypeAllocSize(chanType)
 	sizeValue := llvm.ConstInt(c.uintptrType, size, false)
@@ -32,66 +22,58 @@ func (c *Compiler) emitMakeChan(expr *ssa.MakeChan) (llvm.Value, error) {
 
 // emitChanSend emits a pseudo chan send operation. It is lowered to the actual
 // channel send operation during goroutine lowering.
-func (c *Compiler) emitChanSend(frame *Frame, instr *ssa.Send) error {
-	valueType, err := c.getLLVMType(instr.Chan.Type().(*types.Chan).Elem())
-	if err != nil {
-		return err
-	}
-	ch, err := c.parseExpr(frame, instr.Chan)
-	if err != nil {
-		return err
-	}
-	chanValue, err := c.parseExpr(frame, instr.X)
-	if err != nil {
-		return err
-	}
-	valueSize := llvm.ConstInt(c.uintptrType, c.targetData.TypeAllocSize(chanValue.Type()), false)
-	valueAlloca := c.builder.CreateAlloca(valueType, "chan.value")
+func (c *Compiler) emitChanSend(frame *Frame, instr *ssa.Send) {
+	ch := c.getValue(frame, instr.Chan)
+	chanValue := c.getValue(frame, instr.X)
+
+	// store value-to-send
+	valueType := c.getLLVMType(instr.X.Type())
+	valueAlloca, valueAllocaCast, valueAllocaSize := c.createTemporaryAlloca(valueType, "chan.value")
 	c.builder.CreateStore(chanValue, valueAlloca)
-	valueAllocaCast := c.builder.CreateBitCast(valueAlloca, c.i8ptrType, "chan.value.i8ptr")
-	c.createRuntimeCall("chanSendStub", []llvm.Value{llvm.Undef(c.i8ptrType), ch, valueAllocaCast, valueSize}, "")
-	return nil
+
+	// Do the send.
+	coroutine := c.createRuntimeCall("getCoroutine", nil, "")
+	valueSize := llvm.ConstInt(c.uintptrType, c.targetData.TypeAllocSize(chanValue.Type()), false)
+	c.createRuntimeCall("chanSend", []llvm.Value{coroutine, ch, valueAllocaCast, valueSize}, "")
+
+	// 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
+	c.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 }
 
 // emitChanRecv emits a pseudo chan receive operation. It is lowered to the
 // actual channel receive operation during goroutine lowering.
-func (c *Compiler) emitChanRecv(frame *Frame, unop *ssa.UnOp) (llvm.Value, error) {
-	valueType, err := c.getLLVMType(unop.X.Type().(*types.Chan).Elem())
-	if err != nil {
-		return llvm.Value{}, err
-	}
+func (c *Compiler) emitChanRecv(frame *Frame, unop *ssa.UnOp) llvm.Value {
+	valueType := c.getLLVMType(unop.X.Type().(*types.Chan).Elem())
+	ch := c.getValue(frame, unop.X)
+
+	// Allocate memory to receive into.
+	valueAlloca, valueAllocaCast, valueAllocaSize := c.createTemporaryAlloca(valueType, "chan.value")
+
+	// Do the receive.
+	coroutine := c.createRuntimeCall("getCoroutine", nil, "")
 	valueSize := llvm.ConstInt(c.uintptrType, c.targetData.TypeAllocSize(valueType), false)
-	ch, err := c.parseExpr(frame, unop.X)
-	if err != nil {
-		return llvm.Value{}, err
-	}
-	valueAlloca := c.builder.CreateAlloca(valueType, "chan.value")
-	valueAllocaCast := c.builder.CreateBitCast(valueAlloca, c.i8ptrType, "chan.value.i8ptr")
-	valueOk := c.builder.CreateAlloca(c.ctx.Int1Type(), "chan.comma-ok.alloca")
-	c.createRuntimeCall("chanRecvStub", []llvm.Value{llvm.Undef(c.i8ptrType), ch, valueAllocaCast, valueOk, valueSize}, "")
+	c.createRuntimeCall("chanRecv", []llvm.Value{coroutine, ch, valueAllocaCast, valueSize}, "")
 	received := c.builder.CreateLoad(valueAlloca, "chan.received")
+	c.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+
 	if unop.CommaOk {
-		commaOk := c.builder.CreateLoad(valueOk, "chan.comma-ok")
+		commaOk := c.createRuntimeCall("getTaskPromiseData", []llvm.Value{coroutine}, "chan.commaOk.wide")
+		commaOk = c.builder.CreateTrunc(commaOk, c.ctx.Int1Type(), "chan.commaOk")
 		tuple := llvm.Undef(c.ctx.StructType([]llvm.Type{valueType, c.ctx.Int1Type()}, false))
 		tuple = c.builder.CreateInsertValue(tuple, received, 0, "")
 		tuple = c.builder.CreateInsertValue(tuple, commaOk, 1, "")
-		return tuple, nil
+		return tuple
 	} else {
-		return received, nil
+		return received
 	}
 }
 
 // emitChanClose closes the given channel.
-func (c *Compiler) emitChanClose(frame *Frame, param ssa.Value) error {
-	valueType, err := c.getLLVMType(param.Type().(*types.Chan).Elem())
+func (c *Compiler) emitChanClose(frame *Frame, param ssa.Value) {
+	valueType := c.getLLVMType(param.Type().(*types.Chan).Elem())
 	valueSize := llvm.ConstInt(c.uintptrType, c.targetData.TypeAllocSize(valueType), false)
-	if err != nil {
-		return err
-	}
-	ch, err := c.parseExpr(frame, param)
-	if err != nil {
-		return err
-	}
+	ch := c.getValue(frame, param)
 	c.createRuntimeCall("chanClose", []llvm.Value{ch, valueSize}, "")
-	return nil
 }

compiler/defer.go

@@ -36,7 +36,7 @@ func (c *Compiler) deferInitFunc(frame *Frame) {
 
 // emitDefer emits a single defer instruction, to be run when this function
 // returns.
-func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) error {
+func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) {
 	// The pointer to the previous defer struct, which we will replace to
 	// make a linked list.
 	next := c.builder.CreateLoad(frame.deferPtr, "defer.next")
@@ -56,18 +56,12 @@ func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) error {
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by the call parameters).
-		itf, err := c.parseExpr(frame, instr.Call.Value) // interface
-		if err != nil {
-			return err
-		}
+		itf := c.getValue(frame, instr.Call.Value) // interface
 		receiverValue := c.builder.CreateExtractValue(itf, 1, "invoke.func.receiver")
 		values = []llvm.Value{callback, next, receiverValue}
 		valueTypes = append(valueTypes, c.i8ptrType)
 		for _, arg := range instr.Call.Args {
-			val, err := c.parseExpr(frame, arg)
-			if err != nil {
-				return err
-			}
+			val := c.getValue(frame, arg)
 			values = append(values, val)
 			valueTypes = append(valueTypes, val.Type())
 		}
@@ -86,10 +80,7 @@ func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) error {
 		// runtime._defer fields).
 		values = []llvm.Value{callback, next}
 		for _, param := range instr.Call.Args {
-			llvmParam, err := c.parseExpr(frame, param)
-			if err != nil {
-				return err
-			}
+			llvmParam := c.getValue(frame, param)
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
@@ -101,10 +92,7 @@ func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) error {
 		// pointer.
 		// TODO: ignore this closure entirely and put pointers to the free
 		// variables directly in the defer struct, avoiding a memory allocation.
-		closure, err := c.parseExpr(frame, instr.Call.Value)
-		if err != nil {
-			return err
-		}
+		closure := c.getValue(frame, instr.Call.Value)
 		context := c.builder.CreateExtractValue(closure, 0, "")
 
 		// Get the callback number.
@@ -120,10 +108,7 @@ func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) error {
 		// context pointer).
 		values = []llvm.Value{callback, next}
 		for _, param := range instr.Call.Args {
-			llvmParam, err := c.parseExpr(frame, param)
-			if err != nil {
-				return err
-			}
+			llvmParam := c.getValue(frame, param)
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
@@ -131,15 +116,13 @@ func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) error {
 		valueTypes = append(valueTypes, context.Type())
 
 	} else {
-		return c.makeError(instr.Pos(), "todo: defer on uncommon function call type")
+		c.addError(instr.Pos(), "todo: defer on uncommon function call type")
+		return
 	}
 
 	// Make a struct out of the collected values to put in the defer frame.
 	deferFrameType := c.ctx.StructType(valueTypes, false)
-	deferFrame, err := c.getZeroValue(deferFrameType)
-	if err != nil {
-		return err
-	}
+	deferFrame := c.getZeroValue(deferFrameType)
 	for i, value := range values {
 		deferFrame = c.builder.CreateInsertValue(deferFrame, value, i, "")
 	}
@@ -151,11 +134,10 @@ func (c *Compiler) emitDefer(frame *Frame, instr *ssa.Defer) error {
 	// Push it on top of the linked list by replacing deferPtr.
 	allocaCast := c.builder.CreateBitCast(alloca, next.Type(), "defer.alloca.cast")
 	c.builder.CreateStore(allocaCast, frame.deferPtr)
-	return nil
 }
 
 // emitRunDefers emits code to run all deferred functions.
-func (c *Compiler) emitRunDefers(frame *Frame) error {
+func (c *Compiler) emitRunDefers(frame *Frame) {
 	// Add a loop like the following:
 	//     for stack != nil {
 	//         _stack := stack
@@ -190,13 +172,13 @@ func (c *Compiler) emitRunDefers(frame *Frame) error {
 	//     stack = stack.next
 	//     switch stack.callback {
 	c.builder.SetInsertPointAtEnd(loop)
-	nextStackGEP := c.builder.CreateGEP(deferData, []llvm.Value{
+	nextStackGEP := c.builder.CreateInBoundsGEP(deferData, []llvm.Value{
 		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
 		llvm.ConstInt(c.ctx.Int32Type(), 1, false), // .next field
 	}, "stack.next.gep")
 	nextStack := c.builder.CreateLoad(nextStackGEP, "stack.next")
 	c.builder.CreateStore(nextStack, frame.deferPtr)
-	gep := c.builder.CreateGEP(deferData, []llvm.Value{
+	gep := c.builder.CreateInBoundsGEP(deferData, []llvm.Value{
 		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
 		llvm.ConstInt(c.ctx.Int32Type(), 0, false), // .callback field
 	}, "callback.gep")
@@ -220,11 +202,7 @@ func (c *Compiler) emitRunDefers(frame *Frame) error {
 			// Get the real defer struct type and cast to it.
 			valueTypes := []llvm.Type{c.uintptrType, llvm.PointerType(c.mod.GetTypeByName("runtime._defer"), 0), c.i8ptrType}
 			for _, arg := range callback.Args {
-				llvmType, err := c.getLLVMType(arg.Type())
-				if err != nil {
-					return err
-				}
-				valueTypes = append(valueTypes, llvmType)
+				valueTypes = append(valueTypes, c.getLLVMType(arg.Type()))
 			}
 			deferFrameType := c.ctx.StructType(valueTypes, false)
 			deferFramePtr := c.builder.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
@@ -233,7 +211,7 @@ func (c *Compiler) emitRunDefers(frame *Frame) error {
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := c.builder.CreateGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false)}, "gep")
+				gep := c.builder.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false)}, "gep")
 				forwardParam := c.builder.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
@@ -246,10 +224,7 @@ func (c *Compiler) emitRunDefers(frame *Frame) error {
 			// Parent coroutine handle.
 			forwardParams = append(forwardParams, llvm.Undef(c.i8ptrType))
 
-			fnPtr, _, err := c.getInvokeCall(frame, callback)
-			if err != nil {
-				return err
-			}
+			fnPtr, _ := c.getInvokeCall(frame, callback)
 			c.createCall(fnPtr, forwardParams, "")
 
 		case *ir.Function:
@@ -258,11 +233,7 @@ func (c *Compiler) emitRunDefers(frame *Frame) error {
 			// Get the real defer struct type and cast to it.
 			valueTypes := []llvm.Type{c.uintptrType, llvm.PointerType(c.mod.GetTypeByName("runtime._defer"), 0)}
 			for _, param := range callback.Params {
-				llvmType, err := c.getLLVMType(param.Type())
-				if err != nil {
-					return err
-				}
-				valueTypes = append(valueTypes, llvmType)
+				valueTypes = append(valueTypes, c.getLLVMType(param.Type()))
 			}
 			deferFrameType := c.ctx.StructType(valueTypes, false)
 			deferFramePtr := c.builder.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
@@ -271,7 +242,7 @@ func (c *Compiler) emitRunDefers(frame *Frame) error {
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 			for i := range callback.Params {
-				gep := c.builder.CreateGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i+2), false)}, "gep")
+				gep := c.builder.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i+2), false)}, "gep")
 				forwardParam := c.builder.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
@@ -292,11 +263,7 @@ func (c *Compiler) emitRunDefers(frame *Frame) error {
 			valueTypes := []llvm.Type{c.uintptrType, llvm.PointerType(c.mod.GetTypeByName("runtime._defer"), 0)}
 			params := fn.Signature.Params()
 			for i := 0; i < params.Len(); i++ {
-				llvmType, err := c.getLLVMType(params.At(i).Type())
-				if err != nil {
-					return err
-				}
-				valueTypes = append(valueTypes, llvmType)
+				valueTypes = append(valueTypes, c.getLLVMType(params.At(i).Type()))
 			}
 			valueTypes = append(valueTypes, c.i8ptrType) // closure
 			deferFrameType := c.ctx.StructType(valueTypes, false)
@@ -306,7 +273,7 @@ func (c *Compiler) emitRunDefers(frame *Frame) error {
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := c.builder.CreateGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false)}, "")
+				gep := c.builder.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false)}, "")
 				forwardParam := c.builder.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
@@ -334,5 +301,4 @@ func (c *Compiler) emitRunDefers(frame *Frame) error {
 
 	// End of loop.
 	c.builder.SetInsertPointAtEnd(end)
-	return nil
 }

compiler/errors.go

@@ -12,3 +12,7 @@ func (c *Compiler) makeError(pos token.Pos, msg string) types.Error {
 		Msg:  msg,
 	}
 }
+
+func (c *Compiler) addError(pos token.Pos, msg string) {
+	c.diagnostics = append(c.diagnostics, c.makeError(pos, msg))
+}

compiler/func-lowering.go

@@ -154,17 +154,17 @@ func (c *Compiler) LowerFuncValues() {
 				// What we'll do is transform the following:
 				//     rawPtr := runtime.getFuncPtr(fn)
 				//     if func.rawPtr == nil {
-				//         runtime.nilpanic()
+				//         runtime.nilPanic()
 				//     }
 				//     result := func.rawPtr(...args, func.context)
 				// into this:
 				//     if false {
-				//         runtime.nilpanic()
+				//         runtime.nilPanic()
 				//     }
 				//     var result // Phi
 				//     switch fn.id {
 				//     case 0:
-				//         runtime.nilpanic()
+				//         runtime.nilPanic()
 				//     case 1:
 				//         result = call first implementation...
 				//     case 2:
@@ -222,7 +222,7 @@ func (c *Compiler) LowerFuncValues() {
 				// The 0 case, which is actually a nil check.
 				nilBlock := llvm.InsertBasicBlock(nextBlock, "func.nil")
 				c.builder.SetInsertPointAtEnd(nilBlock)
-				c.createRuntimeCall("nilpanic", nil, "")
+				c.createRuntimeCall("nilPanic", nil, "")
 				c.builder.CreateUnreachable()
 				sw.AddCase(llvm.ConstInt(c.uintptrType, 0, false), nilBlock)
 

compiler/func.go

@@ -41,7 +41,7 @@ func (c *Compiler) funcImplementation() funcValueImplementation {
 
 // createFuncValue creates a function value from a raw function pointer with no
 // context.
-func (c *Compiler) createFuncValue(funcPtr, context llvm.Value, sig *types.Signature) (llvm.Value, error) {
+func (c *Compiler) createFuncValue(funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
 	var funcValueScalar llvm.Value
 	switch c.funcImplementation() {
 	case funcValueDoubleword:
@@ -66,14 +66,11 @@ func (c *Compiler) createFuncValue(funcPtr, context llvm.Value, sig *types.Signa
 	default:
 		panic("unimplemented func value variant")
 	}
-	funcValueType, err := c.getFuncType(sig)
-	if err != nil {
-		return llvm.Value{}, err
-	}
+	funcValueType := c.getFuncType(sig)
 	funcValue := llvm.Undef(funcValueType)
 	funcValue = c.builder.CreateInsertValue(funcValue, context, 0, "")
 	funcValue = c.builder.CreateInsertValue(funcValue, funcValueScalar, 1, "")
-	return funcValue, nil
+	return funcValue
 }
 
 // getFuncSignature returns a global for identification of a particular function
@@ -112,10 +109,7 @@ func (c *Compiler) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (
 	case funcValueDoubleword:
 		funcPtr = c.builder.CreateExtractValue(funcValue, 1, "")
 	case funcValueSwitch:
-		llvmSig, err := c.getRawFuncType(sig)
-		if err != nil {
-			return llvm.Value{}, llvm.Value{}, err
-		}
+		llvmSig := c.getRawFuncType(sig)
 		sigGlobal := c.getFuncSignature(sig)
 		funcPtr = c.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
 		funcPtr = c.builder.CreateIntToPtr(funcPtr, llvmSig, "")
@@ -126,25 +120,21 @@ func (c *Compiler) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (
 }
 
 // getFuncType returns the type of a func value given a signature.
-func (c *Compiler) getFuncType(typ *types.Signature) (llvm.Type, error) {
+func (c *Compiler) getFuncType(typ *types.Signature) llvm.Type {
 	switch c.funcImplementation() {
 	case funcValueDoubleword:
-		rawPtr, err := c.getRawFuncType(typ)
-		if err != nil {
-			return llvm.Type{}, err
-		}
-		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false), nil
+		rawPtr := c.getRawFuncType(typ)
+		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false)
 	case funcValueSwitch:
-		return c.mod.GetTypeByName("runtime.funcValue"), nil
+		return c.mod.GetTypeByName("runtime.funcValue")
 	default:
 		panic("unimplemented func value variant")
 	}
 }
 
 // getRawFuncType returns a LLVM function pointer type for a given signature.
-func (c *Compiler) getRawFuncType(typ *types.Signature) (llvm.Type, error) {
+func (c *Compiler) getRawFuncType(typ *types.Signature) llvm.Type {
 	// Get the return type.
-	var err error
 	var returnType llvm.Type
 	switch typ.Results().Len() {
 	case 0:
@@ -152,21 +142,14 @@ func (c *Compiler) getRawFuncType(typ *types.Signature) (llvm.Type, error) {
 		returnType = c.ctx.VoidType()
 	case 1:
 		// Just one return value.
-		returnType, err = c.getLLVMType(typ.Results().At(0).Type())
-		if err != nil {
-			return llvm.Type{}, err
-		}
+		returnType = c.getLLVMType(typ.Results().At(0).Type())
 	default:
 		// Multiple return values. Put them together in a struct.
 		// This appears to be the common way to handle multiple return values in
 		// LLVM.
 		members := make([]llvm.Type, typ.Results().Len())
 		for i := 0; i < typ.Results().Len(); i++ {
-			returnType, err := c.getLLVMType(typ.Results().At(i).Type())
-			if err != nil {
-				return llvm.Type{}, err
-			}
-			members[i] = returnType
+			members[i] = c.getLLVMType(typ.Results().At(i).Type())
 		}
 		returnType = c.ctx.StructType(members, false)
 	}
@@ -174,10 +157,7 @@ func (c *Compiler) getRawFuncType(typ *types.Signature) (llvm.Type, error) {
 	// Get the parameter types.
 	var paramTypes []llvm.Type
 	if typ.Recv() != nil {
-		recv, err := c.getLLVMType(typ.Recv().Type())
-		if err != nil {
-			return llvm.Type{}, err
-		}
+		recv := c.getLLVMType(typ.Recv().Type())
 		if recv.StructName() == "runtime._interface" {
 			// This is a call on an interface, not a concrete type.
 			// The receiver is not an interface, but a i8* type.
@@ -186,10 +166,7 @@ func (c *Compiler) getRawFuncType(typ *types.Signature) (llvm.Type, error) {
 		paramTypes = append(paramTypes, c.expandFormalParamType(recv)...)
 	}
 	for i := 0; i < typ.Params().Len(); i++ {
-		subType, err := c.getLLVMType(typ.Params().At(i).Type())
-		if err != nil {
-			return llvm.Type{}, err
-		}
+		subType := c.getLLVMType(typ.Params().At(i).Type())
 		paramTypes = append(paramTypes, c.expandFormalParamType(subType)...)
 	}
 	// All functions take these parameters at the end.
@@ -197,7 +174,7 @@ func (c *Compiler) getRawFuncType(typ *types.Signature) (llvm.Type, error) {
 	paramTypes = append(paramTypes, c.i8ptrType) // parent coroutine
 
 	// Make a func type out of the signature.
-	return llvm.PointerType(llvm.FunctionType(returnType, paramTypes, false), c.funcPtrAddrSpace), nil
+	return llvm.PointerType(llvm.FunctionType(returnType, paramTypes, false), c.funcPtrAddrSpace)
 }
 
 // parseMakeClosure makes a function value (with context) from the given
@@ -209,57 +186,17 @@ func (c *Compiler) parseMakeClosure(frame *Frame, expr *ssa.MakeClosure) (llvm.V
 	f := c.ir.GetFunction(expr.Fn.(*ssa.Function))
 
 	// Collect all bound variables.
-	boundVars := make([]llvm.Value, 0, len(expr.Bindings))
-	boundVarTypes := make([]llvm.Type, 0, len(expr.Bindings))
-	for _, binding := range expr.Bindings {
+	boundVars := make([]llvm.Value, len(expr.Bindings))
+	for i, binding := range expr.Bindings {
 		// The context stores the bound variables.
-		llvmBoundVar, err := c.parseExpr(frame, binding)
-		if err != nil {
-			return llvm.Value{}, err
-		}
-		boundVars = append(boundVars, llvmBoundVar)
-		boundVarTypes = append(boundVarTypes, llvmBoundVar.Type())
-	}
-	contextType := c.ctx.StructType(boundVarTypes, false)
-
-	// Allocate memory for the context.
-	contextAlloc := llvm.Value{}
-	contextHeapAlloc := llvm.Value{}
-	if c.targetData.TypeAllocSize(contextType) <= c.targetData.TypeAllocSize(c.i8ptrType) {
-		// Context fits in a pointer - e.g. when it is a pointer. Store it
-		// directly in the stack after a convert.
-		// Because contextType is a struct and we have to cast it to a *i8,
-		// store it in an alloca first for bitcasting (store+bitcast+load).
-		contextAlloc = c.builder.CreateAlloca(contextType, "")
-	} else {
-		// Context is bigger than a pointer, so allocate it on the heap.
-		size := c.targetData.TypeAllocSize(contextType)
-		sizeValue := llvm.ConstInt(c.uintptrType, size, false)
-		contextHeapAlloc = c.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "")
-		contextAlloc = c.builder.CreateBitCast(contextHeapAlloc, llvm.PointerType(contextType, 0), "")
+		llvmBoundVar := c.getValue(frame, binding)
+		boundVars[i] = llvmBoundVar
 	}
 
-	// Store all bound variables in the alloca or heap pointer.
-	for i, boundVar := range boundVars {
-		indices := []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false),
-		}
-		gep := c.builder.CreateInBoundsGEP(contextAlloc, indices, "")
-		c.builder.CreateStore(boundVar, gep)
-	}
-
-	context := llvm.Value{}
-	if c.targetData.TypeAllocSize(contextType) <= c.targetData.TypeAllocSize(c.i8ptrType) {
-		// Load value (as *i8) from the alloca.
-		contextAlloc = c.builder.CreateBitCast(contextAlloc, llvm.PointerType(c.i8ptrType, 0), "")
-		context = c.builder.CreateLoad(contextAlloc, "")
-	} else {
-		// Get the original heap allocation pointer, which already is an
-		// *i8.
-		context = contextHeapAlloc
-	}
+	// Store the bound variables in a single object, allocating it on the heap
+	// if necessary.
+	context := c.emitPointerPack(boundVars)
 
 	// Create the closure.
-	return c.createFuncValue(f.LLVMFn, context, f.Signature)
+	return c.createFuncValue(f.LLVMFn, context, f.Signature), nil
 }

compiler/goroutine-lowering.go

@@ -10,8 +10,8 @@ package compiler
 //         go foo()
 //         time.Sleep(2 * time.Second)
 //         println("some other operation")
-//         bar()
-//         println("done")
+//         i := bar()
+//         println("done", *i)
 //     }
 //
 //     func foo() {
@@ -21,9 +21,10 @@ package compiler
 //         }
 //     }
 //
-//     func bar() {
+//     func bar() *int {
 //         time.Sleep(time.Second)
 //         println("blocking operation completed)
+//         return new(int)
 //     }
 //
 // It is transformed by the IR generator in compiler.go into the following
@@ -34,8 +35,8 @@ package compiler
 //         fn()
 //         time.Sleep(2 * time.Second)
 //         println("some other operation")
-//         bar() // imagine an 'await' keyword in front of this call
-//         println("done")
+//         i := bar() // imagine an 'await' keyword in front of this call
+//         println("done", *i)
 //     }
 //
 //     func foo() {
@@ -45,9 +46,10 @@ package compiler
 //         }
 //     }
 //
-//     func bar() {
+//     func bar() *int {
 //         time.Sleep(time.Second)
 //         println("blocking operation completed)
+//         return new(int)
 //     }
 //
 // The pass in this file transforms this code even further, to the following
@@ -59,9 +61,11 @@ package compiler
 //         runtime.sleepTask(hdl, 2 * time.Second) // ask the scheduler to re-activate this coroutine at the right time
 //         llvm.suspend(hdl)                       // suspend point
 //         println("some other operation")
+//         var i *int                              // allocate space on the stack for the return value
+//         runtime.setTaskPromisePtr(hdl, &i)      // store return value alloca in our coroutine promise
 //         bar(hdl)                                // await, pass a continuation (hdl) to bar
 //         llvm.suspend(hdl)                       // suspend point, wait for the callee to re-activate
-//         println("done")
+//         println("done", *i)
 //         runtime.activateTask(parent)            // re-activate the parent (nop, there is no parent)
 //     }
 //
@@ -142,10 +146,9 @@ func (c *Compiler) LowerGoroutines() error {
 	realMain.SetLinkage(llvm.InternalLinkage)
 	c.mod.NamedFunction("runtime.alloc").SetLinkage(llvm.InternalLinkage)
 	c.mod.NamedFunction("runtime.free").SetLinkage(llvm.InternalLinkage)
-	c.mod.NamedFunction("runtime.chanSend").SetLinkage(llvm.InternalLinkage)
-	c.mod.NamedFunction("runtime.chanRecv").SetLinkage(llvm.InternalLinkage)
 	c.mod.NamedFunction("runtime.sleepTask").SetLinkage(llvm.InternalLinkage)
-	c.mod.NamedFunction("runtime.activateTask").SetLinkage(llvm.InternalLinkage)
+	c.mod.NamedFunction("runtime.setTaskPromisePtr").SetLinkage(llvm.InternalLinkage)
+	c.mod.NamedFunction("runtime.getTaskPromisePtr").SetLinkage(llvm.InternalLinkage)
 	c.mod.NamedFunction("runtime.scheduler").SetLinkage(llvm.InternalLinkage)
 
 	return nil
@@ -174,13 +177,13 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 	if !deadlockStub.IsNil() {
 		worklist = append(worklist, deadlockStub)
 	}
-	chanSendStub := c.mod.NamedFunction("runtime.chanSendStub")
-	if !chanSendStub.IsNil() {
-		worklist = append(worklist, chanSendStub)
+	chanSend := c.mod.NamedFunction("runtime.chanSend")
+	if !chanSend.IsNil() {
+		worklist = append(worklist, chanSend)
 	}
-	chanRecvStub := c.mod.NamedFunction("runtime.chanRecvStub")
-	if !chanRecvStub.IsNil() {
-		worklist = append(worklist, chanRecvStub)
+	chanRecv := c.mod.NamedFunction("runtime.chanRecv")
+	if !chanRecv.IsNil() {
+		worklist = append(worklist, chanRecv)
 	}
 
 	if len(worklist) == 0 {
@@ -278,9 +281,6 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 	coroBeginType := llvm.FunctionType(c.i8ptrType, []llvm.Type{c.ctx.TokenType(), c.i8ptrType}, false)
 	coroBeginFunc := llvm.AddFunction(c.mod, "llvm.coro.begin", coroBeginType)
 
-	coroPromiseType := llvm.FunctionType(c.i8ptrType, []llvm.Type{c.i8ptrType, c.ctx.Int32Type(), c.ctx.Int1Type()}, false)
-	coroPromiseFunc := llvm.AddFunction(c.mod, "llvm.coro.promise", coroPromiseType)
-
 	coroSuspendType := llvm.FunctionType(c.ctx.Int8Type(), []llvm.Type{c.ctx.TokenType(), c.ctx.Int1Type()}, false)
 	coroSuspendFunc := llvm.AddFunction(c.mod, "llvm.coro.suspend", coroSuspendType)
 
@@ -292,7 +292,7 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 
 	// Transform all async functions into coroutines.
 	for _, f := range asyncList {
-		if f == sleep || f == deadlockStub || f == chanSendStub || f == chanRecvStub {
+		if f == sleep || f == deadlockStub || f == chanSend || f == chanRecv {
 			continue
 		}
 
@@ -309,7 +309,7 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 			for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
 				if !inst.IsACallInst().IsNil() {
 					callee := inst.CalledValue()
-					if _, ok := asyncFuncs[callee]; !ok || callee == sleep || callee == deadlockStub || callee == chanSendStub || callee == chanRecvStub {
+					if _, ok := asyncFuncs[callee]; !ok || callee == sleep || callee == deadlockStub || callee == chanSend || callee == chanRecv {
 						continue
 					}
 					asyncCalls = append(asyncCalls, inst)
@@ -347,10 +347,18 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 			// Split this basic block.
 			await := c.splitBasicBlock(inst, llvm.NextBasicBlock(c.builder.GetInsertBlock()), "task.await")
 
-			// Set task state to TASK_STATE_CALL.
-			c.builder.SetInsertPointAtEnd(inst.InstructionParent())
+			// Allocate space for the return value.
+			var retvalAlloca llvm.Value
+			if inst.Type().TypeKind() != llvm.VoidTypeKind {
+				c.builder.SetInsertPointBefore(inst.InstructionParent().Parent().EntryBasicBlock().FirstInstruction())
+				retvalAlloca = c.builder.CreateAlloca(inst.Type(), "coro.retvalAlloca")
+				c.builder.SetInsertPointBefore(inst)
+				data := c.builder.CreateBitCast(retvalAlloca, c.i8ptrType, "")
+				c.createRuntimeCall("setTaskPromisePtr", []llvm.Value{frame.taskHandle, data}, "")
+			}
 
 			// Suspend.
+			c.builder.SetInsertPointAtEnd(inst.InstructionParent())
 			continuePoint := c.builder.CreateCall(coroSuspendFunc, []llvm.Value{
 				llvm.ConstNull(c.ctx.TokenType()),
 				llvm.ConstInt(c.ctx.Int1Type(), 0, false),
@@ -358,44 +366,76 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 			sw := c.builder.CreateSwitch(continuePoint, frame.suspendBlock, 2)
 			sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 0, false), await)
 			sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 1, false), frame.cleanupBlock)
+
+			if inst.Type().TypeKind() != llvm.VoidTypeKind {
+				// Load the return value from the alloca. The callee has
+				// written the return value to it.
+				c.builder.SetInsertPointBefore(await.FirstInstruction())
+				retval := c.builder.CreateLoad(retvalAlloca, "coro.retval")
+				inst.ReplaceAllUsesWith(retval)
+			}
 		}
 
 		// Replace return instructions with suspend points that should
 		// reactivate the parent coroutine.
 		for _, inst := range returns {
-			if inst.OperandsCount() == 0 {
-				// These properties were added by the functionattrs pass.
-				// Remove them, because now we start using the parameter.
-				// https://llvm.org/docs/Passes.html#functionattrs-deduce-function-attributes
-				for _, kind := range []string{"nocapture", "readnone"} {
-					kindID := llvm.AttributeKindID(kind)
-					f.RemoveEnumAttributeAtIndex(f.ParamsCount(), kindID)
-				}
-
-				// Reactivate the parent coroutine. This adds it back to
-				// the run queue, so it is started again by the
-				// scheduler when possible (possibly right after the
-				// following suspend).
-				c.builder.SetInsertPointBefore(inst)
-
-				parentHandle := f.LastParam()
-				c.createRuntimeCall("activateTask", []llvm.Value{parentHandle}, "")
-
-				// Suspend this coroutine.
-				// It would look like this is unnecessary, but if this
-				// suspend point is left out, it leads to undefined
-				// behavior somehow (with the unreachable instruction).
-				continuePoint := c.builder.CreateCall(coroSuspendFunc, []llvm.Value{
-					llvm.ConstNull(c.ctx.TokenType()),
-					llvm.ConstInt(c.ctx.Int1Type(), 1, false),
-				}, "ret")
-				sw := c.builder.CreateSwitch(continuePoint, frame.suspendBlock, 2)
-				sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 0, false), frame.unreachableBlock)
-				sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 1, false), frame.cleanupBlock)
-				inst.EraseFromParentAsInstruction()
-			} else {
-				panic("todo: return value from coroutine")
+			// These properties were added by the functionattrs pass. Remove
+			// them, because now we start using the parameter.
+			// https://llvm.org/docs/Passes.html#functionattrs-deduce-function-attributes
+			for _, kind := range []string{"nocapture", "readnone"} {
+				kindID := llvm.AttributeKindID(kind)
+				f.RemoveEnumAttributeAtIndex(f.ParamsCount(), kindID)
 			}
+
+			c.builder.SetInsertPointBefore(inst)
+
+			var parentHandle llvm.Value
+			if f.Linkage() == llvm.ExternalLinkage {
+				// Exported function.
+				// Note that getTaskPromisePtr will panic if it is called with
+				// a nil pointer, so blocking exported functions that try to
+				// return anything will not work.
+				parentHandle = llvm.ConstPointerNull(c.i8ptrType)
+			} else {
+				parentHandle = f.LastParam()
+				if parentHandle.IsNil() || parentHandle.Name() != "parentHandle" {
+					// sanity check
+					panic("trying to make exported function async")
+				}
+			}
+
+			// Store return values.
+			switch inst.OperandsCount() {
+			case 0:
+				// Nothing to return.
+			case 1:
+				// Return this value by writing to the pointer stored in the
+				// parent handle. The parent coroutine has made an alloca that
+				// we can write to to store our return value.
+				returnValuePtr := c.createRuntimeCall("getTaskPromisePtr", []llvm.Value{parentHandle}, "coro.parentData")
+				alloca := c.builder.CreateBitCast(returnValuePtr, llvm.PointerType(inst.Operand(0).Type(), 0), "coro.parentAlloca")
+				c.builder.CreateStore(inst.Operand(0), alloca)
+			default:
+				panic("unreachable")
+			}
+
+			// Reactivate the parent coroutine. This adds it back to the run
+			// queue, so it is started again by the scheduler when possible
+			// (possibly right after the following suspend).
+			c.createRuntimeCall("activateTask", []llvm.Value{parentHandle}, "")
+
+			// Suspend this coroutine.
+			// It would look like this is unnecessary, but if this
+			// suspend point is left out, it leads to undefined
+			// behavior somehow (with the unreachable instruction).
+			continuePoint := c.builder.CreateCall(coroSuspendFunc, []llvm.Value{
+				llvm.ConstNull(c.ctx.TokenType()),
+				llvm.ConstInt(c.ctx.Int1Type(), 0, false),
+			}, "ret")
+			sw := c.builder.CreateSwitch(continuePoint, frame.suspendBlock, 2)
+			sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 0, false), frame.unreachableBlock)
+			sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 1, false), frame.cleanupBlock)
+			inst.EraseFromParentAsInstruction()
 		}
 
 		// Coroutine cleanup. Free resources associated with this coroutine.
@@ -420,6 +460,14 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 		c.builder.CreateUnreachable()
 	}
 
+	// Replace calls to runtime.getCoroutineCall with the coroutine of this
+	// frame.
+	for _, getCoroutineCall := range getUses(c.mod.NamedFunction("runtime.getCoroutine")) {
+		frame := asyncFuncs[getCoroutineCall.InstructionParent().Parent()]
+		getCoroutineCall.ReplaceAllUsesWith(frame.taskHandle)
+		getCoroutineCall.EraseFromParentAsInstruction()
+	}
+
 	// Transform calls to time.Sleep() into coroutine suspend points.
 	for _, sleepCall := range getUses(sleep) {
 		// sleepCall must be a call instruction.
@@ -453,7 +501,7 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 		c.builder.SetInsertPointBefore(deadlockCall)
 		continuePoint := c.builder.CreateCall(coroSuspendFunc, []llvm.Value{
 			llvm.ConstNull(c.ctx.TokenType()),
-			llvm.ConstInt(c.ctx.Int1Type(), 1, false), // final suspend
+			llvm.ConstInt(c.ctx.Int1Type(), 0, false),
 		}, "")
 		c.splitBasicBlock(deadlockCall, llvm.NextBasicBlock(c.builder.GetInsertBlock()), "task.wakeup.dead")
 		c.builder.SetInsertPointBefore(deadlockCall)
@@ -463,37 +511,11 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 		deadlockCall.EraseFromParentAsInstruction()
 	}
 
-	// Transform calls to runtime.chanSendStub into channel send operations.
-	for _, sendOp := range getUses(chanSendStub) {
+	// Transform calls to runtime.chanSend into channel send operations.
+	for _, sendOp := range getUses(chanSend) {
 		// sendOp must be a call instruction.
 		frame := asyncFuncs[sendOp.InstructionParent().Parent()]
 
-		// Send the value over the channel, or block.
-		sendOp.SetOperand(0, frame.taskHandle)
-		sendOp.SetOperand(sendOp.OperandsCount()-1, c.mod.NamedFunction("runtime.chanSend"))
-
-		// Use taskState.data to store the value to send:
-		//     *(*valueType)(&coroutine.promise().data) = valueToSend
-		//     runtime.chanSend(coroutine, ch)
-		bitcast := sendOp.Operand(2)
-		valueAlloca := bitcast.Operand(0)
-		c.builder.SetInsertPointBefore(valueAlloca)
-		promiseType := c.mod.GetTypeByName("runtime.taskState")
-		promiseRaw := c.builder.CreateCall(coroPromiseFunc, []llvm.Value{
-			frame.taskHandle,
-			llvm.ConstInt(c.ctx.Int32Type(), uint64(c.targetData.PrefTypeAlignment(promiseType)), false),
-			llvm.ConstInt(c.ctx.Int1Type(), 0, false),
-		}, "task.promise.raw")
-		promise := c.builder.CreateBitCast(promiseRaw, llvm.PointerType(promiseType, 0), "task.promise")
-		dataPtr := c.builder.CreateGEP(promise, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 2, false),
-		}, "task.promise.data")
-		sendOp.SetOperand(2, llvm.Undef(c.i8ptrType))
-		valueAlloca.ReplaceAllUsesWith(c.builder.CreateBitCast(dataPtr, valueAlloca.Type(), ""))
-		bitcast.EraseFromParentAsInstruction()
-		valueAlloca.EraseFromParentAsInstruction()
-
 		// Yield to scheduler.
 		c.builder.SetInsertPointBefore(llvm.NextInstruction(sendOp))
 		continuePoint := c.builder.CreateCall(coroSuspendFunc, []llvm.Value{
@@ -506,21 +528,11 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 		sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 1, false), frame.cleanupBlock)
 	}
 
-	// Transform calls to runtime.chanRecvStub into channel receive operations.
-	for _, recvOp := range getUses(chanRecvStub) {
+	// Transform calls to runtime.chanRecv into channel receive operations.
+	for _, recvOp := range getUses(chanRecv) {
 		// recvOp must be a call instruction.
 		frame := asyncFuncs[recvOp.InstructionParent().Parent()]
 
-		bitcast := recvOp.Operand(2)
-		commaOk := recvOp.Operand(3)
-		valueAlloca := bitcast.Operand(0)
-
-		// Receive the value over the channel, or block.
-		recvOp.SetOperand(0, frame.taskHandle)
-		recvOp.SetOperand(recvOp.OperandsCount()-1, c.mod.NamedFunction("runtime.chanRecv"))
-		recvOp.SetOperand(2, llvm.Undef(c.i8ptrType))
-		bitcast.EraseFromParentAsInstruction()
-
 		// Yield to scheduler.
 		c.builder.SetInsertPointBefore(llvm.NextInstruction(recvOp))
 		continuePoint := c.builder.CreateCall(coroSuspendFunc, []llvm.Value{
@@ -532,32 +544,6 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 		c.builder.SetInsertPointAtEnd(recvOp.InstructionParent())
 		sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 0, false), wakeup)
 		sw.AddCase(llvm.ConstInt(c.ctx.Int8Type(), 1, false), frame.cleanupBlock)
-
-		// The value to receive is stored in taskState.data:
-		//     runtime.chanRecv(coroutine, ch)
-		//     promise := coroutine.promise()
-		//     valueReceived := *(*valueType)(&promise.data)
-		//     ok := promise.commaOk
-		c.builder.SetInsertPointBefore(wakeup.FirstInstruction())
-		promiseType := c.mod.GetTypeByName("runtime.taskState")
-		promiseRaw := c.builder.CreateCall(coroPromiseFunc, []llvm.Value{
-			frame.taskHandle,
-			llvm.ConstInt(c.ctx.Int32Type(), uint64(c.targetData.PrefTypeAlignment(promiseType)), false),
-			llvm.ConstInt(c.ctx.Int1Type(), 0, false),
-		}, "task.promise.raw")
-		promise := c.builder.CreateBitCast(promiseRaw, llvm.PointerType(promiseType, 0), "task.promise")
-		dataPtr := c.builder.CreateGEP(promise, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 2, false),
-		}, "task.promise.data")
-		valueAlloca.ReplaceAllUsesWith(c.builder.CreateBitCast(dataPtr, valueAlloca.Type(), ""))
-		valueAlloca.EraseFromParentAsInstruction()
-		commaOkPtr := c.builder.CreateGEP(promise, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 1, false),
-		}, "task.promise.comma-ok")
-		commaOk.ReplaceAllUsesWith(commaOkPtr)
-		recvOp.SetOperand(3, llvm.Undef(commaOk.Type()))
 	}
 
 	return true, c.lowerMakeGoroutineCalls()

compiler/inlineasm.go

@@ -68,11 +68,7 @@ func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value,
 			}
 			key := constant.StringVal(r.Key.(*ssa.Const).Value)
 			//println("value:", r.Value.(*ssa.MakeInterface).X.String())
-			value, err := c.parseExpr(frame, r.Value.(*ssa.MakeInterface).X)
-			if err != nil {
-				return llvm.Value{}, err
-			}
-			registers[key] = value
+			registers[key] = c.getValue(frame, r.Value.(*ssa.MakeInterface).X)
 		case *ssa.Call:
 			if r.Common() == instr {
 				break
@@ -145,10 +141,7 @@ func (c *Compiler) emitSVCall(frame *Frame, args []ssa.Value) (llvm.Value, error
 		} else {
 			constraints += ",{r" + strconv.Itoa(i) + "}"
 		}
-		llvmValue, err := c.parseExpr(frame, arg)
-		if err != nil {
-			return llvm.Value{}, err
-		}
+		llvmValue := c.getValue(frame, arg)
 		llvmArgs = append(llvmArgs, llvmValue)
 		argTypes = append(argTypes, llvmValue.Type())
 	}

compiler/interface-lowering.go

@@ -527,11 +527,40 @@ func (p *lowerInterfacesPass) replaceInvokeWithCall(use llvm.Value, typ *typeInf
 	}
 	inttoptr := inttoptrs[0]
 	function := typ.getMethod(signature).function
-	if inttoptr.Type() != function.Type() {
-		p.builder.SetInsertPointBefore(use)
-		function = p.builder.CreateBitCast(function, inttoptr.Type(), "")
+	if inttoptr.Type() == function.Type() {
+		// Easy case: the types are the same. Simply replace the inttoptr
+		// result (which is directly called) with the actual function.
+		inttoptr.ReplaceAllUsesWith(function)
+	} else {
+		// Harder case: the type is not actually the same. Go through each call
+		// (of which there should be only one), extract the receiver params for
+		// this call and replace the call with a direct call to the target
+		// function.
+		for _, call := range getUses(inttoptr) {
+			if call.IsACallInst().IsNil() || call.CalledValue() != inttoptr {
+				panic("expected the inttoptr to be called as a method, this is not a method call")
+			}
+			operands := make([]llvm.Value, call.OperandsCount()-1)
+			for i := range operands {
+				operands[i] = call.Operand(i)
+			}
+			paramTypes := function.Type().ElementType().ParamTypes()
+			receiverParamTypes := paramTypes[:len(paramTypes)-(len(operands)-1)]
+			methodParamTypes := paramTypes[len(paramTypes)-(len(operands)-1):]
+			for i, methodParamType := range methodParamTypes {
+				if methodParamType != operands[i+1].Type() {
+					panic("expected method call param type and function param type to be the same")
+				}
+			}
+			p.builder.SetInsertPointBefore(call)
+			receiverParams := p.emitPointerUnpack(operands[0], receiverParamTypes)
+			result := p.builder.CreateCall(function, append(receiverParams, operands[1:]...), "")
+			if result.Type().TypeKind() != llvm.VoidTypeKind {
+				call.ReplaceAllUsesWith(result)
+			}
+			call.EraseFromParentAsInstruction()
+		}
 	}
-	inttoptr.ReplaceAllUsesWith(function)
 	inttoptr.EraseFromParentAsInstruction()
 	use.EraseFromParentAsInstruction()
 }

compiler/interface.go

@@ -22,43 +22,10 @@ import (
 // value field.
 //
 // An interface value is a {typecode, value} tuple, or {i16, i8*} to be exact.
-func (c *Compiler) parseMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) (llvm.Value, error) {
-	var itfValue llvm.Value
-	size := c.targetData.TypeAllocSize(val.Type())
-	if size > c.targetData.TypeAllocSize(c.i8ptrType) {
-		// Allocate on the heap and put a pointer in the interface.
-		// TODO: escape analysis.
-		sizeValue := llvm.ConstInt(c.uintptrType, size, false)
-		alloc := c.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "makeinterface.alloc")
-		itfValueCast := c.builder.CreateBitCast(alloc, llvm.PointerType(val.Type(), 0), "makeinterface.cast.value")
-		c.builder.CreateStore(val, itfValueCast)
-		itfValue = c.builder.CreateBitCast(itfValueCast, c.i8ptrType, "makeinterface.cast.i8ptr")
-	} else if size == 0 {
-		itfValue = llvm.ConstPointerNull(c.i8ptrType)
-	} else {
-		// Directly place the value in the interface.
-		switch val.Type().TypeKind() {
-		case llvm.IntegerTypeKind:
-			itfValue = c.builder.CreateIntToPtr(val, c.i8ptrType, "makeinterface.cast.int")
-		case llvm.PointerTypeKind:
-			itfValue = c.builder.CreateBitCast(val, c.i8ptrType, "makeinterface.cast.ptr")
-		case llvm.StructTypeKind, llvm.FloatTypeKind, llvm.DoubleTypeKind:
-			// A bitcast would be useful here, but bitcast doesn't allow
-			// aggregate types. So we'll bitcast it using an alloca.
-			// Hopefully this will get optimized away.
-			mem := c.builder.CreateAlloca(c.i8ptrType, "makeinterface.cast.struct")
-			memStructPtr := c.builder.CreateBitCast(mem, llvm.PointerType(val.Type(), 0), "makeinterface.cast.struct.cast")
-			c.builder.CreateStore(val, memStructPtr)
-			itfValue = c.builder.CreateLoad(mem, "makeinterface.cast.load")
-		default:
-			return llvm.Value{}, c.makeError(pos, "todo: makeinterface: cast small type to i8*")
-		}
-	}
+func (c *Compiler) parseMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) llvm.Value {
+	itfValue := c.emitPointerPack([]llvm.Value{val})
 	itfTypeCodeGlobal := c.getTypeCode(typ)
-	itfMethodSetGlobal, err := c.getTypeMethodSet(typ)
-	if err != nil {
-		return llvm.Value{}, nil
-	}
+	itfMethodSetGlobal := c.getTypeMethodSet(typ)
 	itfConcreteTypeGlobal := c.mod.NamedGlobal("typeInInterface:" + itfTypeCodeGlobal.Name())
 	if itfConcreteTypeGlobal.IsNil() {
 		typeInInterface := c.mod.GetTypeByName("runtime.typeInInterface")
@@ -71,7 +38,7 @@ func (c *Compiler) parseMakeInterface(val llvm.Value, typ types.Type, pos token.
 	itf := llvm.Undef(c.mod.GetTypeByName("runtime._interface"))
 	itf = c.builder.CreateInsertValue(itf, itfTypeCode, 0, "")
 	itf = c.builder.CreateInsertValue(itf, itfValue, 1, "")
-	return itf, nil
+	return itf
 }
 
 // getTypeCode returns a reference to a type code.
@@ -185,18 +152,18 @@ func getTypeCodeName(t types.Type) string {
 
 // getTypeMethodSet returns a reference (GEP) to a global method set. This
 // method set should be unreferenced after the interface lowering pass.
-func (c *Compiler) getTypeMethodSet(typ types.Type) (llvm.Value, error) {
+func (c *Compiler) getTypeMethodSet(typ types.Type) llvm.Value {
 	global := c.mod.NamedGlobal(typ.String() + "$methodset")
 	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 	if !global.IsNil() {
 		// the method set already exists
-		return llvm.ConstGEP(global, []llvm.Value{zero, zero}), nil
+		return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 	}
 
 	ms := c.ir.Program.MethodSets.MethodSet(typ)
 	if ms.Len() == 0 {
 		// no methods, so can leave that one out
-		return llvm.ConstPointerNull(llvm.PointerType(c.mod.GetTypeByName("runtime.interfaceMethodInfo"), 0)), nil
+		return llvm.ConstPointerNull(llvm.PointerType(c.mod.GetTypeByName("runtime.interfaceMethodInfo"), 0))
 	}
 
 	methods := make([]llvm.Value, ms.Len())
@@ -209,10 +176,7 @@ func (c *Compiler) getTypeMethodSet(typ types.Type) (llvm.Value, error) {
 			// compiler error, so panic
 			panic("cannot find function: " + f.LinkName())
 		}
-		fn, err := c.getInterfaceInvokeWrapper(f)
-		if err != nil {
-			return llvm.Value{}, err
-		}
+		fn := c.getInterfaceInvokeWrapper(f)
 		methodInfo := llvm.ConstNamedStruct(interfaceMethodInfoType, []llvm.Value{
 			signatureGlobal,
 			llvm.ConstPtrToInt(fn, c.uintptrType),
@@ -225,7 +189,7 @@ func (c *Compiler) getTypeMethodSet(typ types.Type) (llvm.Value, error) {
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
 	global.SetLinkage(llvm.PrivateLinkage)
-	return llvm.ConstGEP(global, []llvm.Value{zero, zero}), nil
+	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 }
 
 // getInterfaceMethodSet returns a global variable with the method set of the
@@ -274,19 +238,9 @@ func (c *Compiler) getMethodSignature(method *types.Func) llvm.Value {
 //
 // Type asserts on concrete types are trivial: just compare type numbers. Type
 // asserts on interfaces are more difficult, see the comments in the function.
-func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) (llvm.Value, error) {
-	itf, err := c.parseExpr(frame, expr.X)
-	if err != nil {
-		return llvm.Value{}, err
-	}
-	assertedType, err := c.getLLVMType(expr.AssertedType)
-	if err != nil {
-		return llvm.Value{}, err
-	}
-	valueNil, err := c.getZeroValue(assertedType)
-	if err != nil {
-		return llvm.Value{}, err
-	}
+func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) llvm.Value {
+	itf := c.getValue(frame, expr.X)
+	assertedType := c.getLLVMType(expr.AssertedType)
 
 	actualTypeNum := c.builder.CreateExtractValue(itf, 0, "interface.type")
 	commaOk := llvm.Value{}
@@ -339,67 +293,35 @@ func (c *Compiler) parseTypeAssert(frame *Frame, expr *ssa.TypeAssert) (llvm.Val
 		// Type assert on concrete type. Extract the underlying type from
 		// the interface (but only after checking it matches).
 		valuePtr := c.builder.CreateExtractValue(itf, 1, "typeassert.value.ptr")
-		size := c.targetData.TypeAllocSize(assertedType)
-		if size > c.targetData.TypeAllocSize(c.i8ptrType) {
-			// Value was stored in an allocated buffer, load it from there.
-			valuePtrCast := c.builder.CreateBitCast(valuePtr, llvm.PointerType(assertedType, 0), "")
-			valueOk = c.builder.CreateLoad(valuePtrCast, "typeassert.value.ok")
-		} else if size == 0 {
-			valueOk, err = c.getZeroValue(assertedType)
-			if err != nil {
-				return llvm.Value{}, err
-			}
-		} else {
-			// Value was stored directly in the interface.
-			switch assertedType.TypeKind() {
-			case llvm.IntegerTypeKind:
-				valueOk = c.builder.CreatePtrToInt(valuePtr, assertedType, "typeassert.value.ok")
-			case llvm.PointerTypeKind:
-				valueOk = c.builder.CreateBitCast(valuePtr, assertedType, "typeassert.value.ok")
-			default: // struct, float, etc.
-				// A bitcast would be useful here, but bitcast doesn't allow
-				// aggregate types. So we'll bitcast it using an alloca.
-				// Hopefully this will get optimized away.
-				mem := c.builder.CreateAlloca(c.i8ptrType, "")
-				c.builder.CreateStore(valuePtr, mem)
-				memCast := c.builder.CreateBitCast(mem, llvm.PointerType(assertedType, 0), "")
-				valueOk = c.builder.CreateLoad(memCast, "typeassert.value.ok")
-			}
-		}
+		valueOk = c.emitPointerUnpack(valuePtr, []llvm.Type{assertedType})[0]
 	}
 	c.builder.CreateBr(nextBlock)
 
 	// Continue after the if statement.
 	c.builder.SetInsertPointAtEnd(nextBlock)
 	phi := c.builder.CreatePHI(assertedType, "typeassert.value")
-	phi.AddIncoming([]llvm.Value{valueNil, valueOk}, []llvm.BasicBlock{prevBlock, okBlock})
+	phi.AddIncoming([]llvm.Value{c.getZeroValue(assertedType), valueOk}, []llvm.BasicBlock{prevBlock, okBlock})
 
 	if expr.CommaOk {
 		tuple := c.ctx.ConstStruct([]llvm.Value{llvm.Undef(assertedType), llvm.Undef(c.ctx.Int1Type())}, false) // create empty tuple
 		tuple = c.builder.CreateInsertValue(tuple, phi, 0, "")                                                  // insert value
 		tuple = c.builder.CreateInsertValue(tuple, commaOk, 1, "")                                              // insert 'comma ok' boolean
-		return tuple, nil
+		return tuple
 	} else {
 		// This is kind of dirty as the branch above becomes mostly useless,
 		// but hopefully this gets optimized away.
 		c.createRuntimeCall("interfaceTypeAssert", []llvm.Value{commaOk}, "")
-		return phi, nil
+		return phi
 	}
 }
 
 // getInvokeCall creates and returns the function pointer and parameters of an
 // interface call. It can be used in a call or defer instruction.
-func (c *Compiler) getInvokeCall(frame *Frame, instr *ssa.CallCommon) (llvm.Value, []llvm.Value, error) {
+func (c *Compiler) getInvokeCall(frame *Frame, instr *ssa.CallCommon) (llvm.Value, []llvm.Value) {
 	// Call an interface method with dynamic dispatch.
-	itf, err := c.parseExpr(frame, instr.Value) // interface
-	if err != nil {
-		return llvm.Value{}, nil, err
-	}
+	itf := c.getValue(frame, instr.Value) // interface
 
-	llvmFnType, err := c.getRawFuncType(instr.Method.Type().(*types.Signature))
-	if err != nil {
-		return llvm.Value{}, nil, err
-	}
+	llvmFnType := c.getRawFuncType(instr.Method.Type().(*types.Signature))
 
 	typecode := c.builder.CreateExtractValue(itf, 0, "invoke.typecode")
 	values := []llvm.Value{
@@ -413,11 +335,7 @@ func (c *Compiler) getInvokeCall(frame *Frame, instr *ssa.CallCommon) (llvm.Valu
 
 	args := []llvm.Value{receiverValue}
 	for _, arg := range instr.Args {
-		val, err := c.parseExpr(frame, arg)
-		if err != nil {
-			return llvm.Value{}, nil, err
-		}
-		args = append(args, val)
+		args = append(args, c.getValue(frame, arg))
 	}
 	// Add the context parameter. An interface call never takes a context but we
 	// have to supply the parameter anyway.
@@ -425,7 +343,7 @@ func (c *Compiler) getInvokeCall(frame *Frame, instr *ssa.CallCommon) (llvm.Valu
 	// Add the parent goroutine handle.
 	args = append(args, llvm.Undef(c.i8ptrType))
 
-	return fnCast, args, nil
+	return fnCast, args
 }
 
 // interfaceInvokeWrapper keeps some state between getInterfaceInvokeWrapper and
@@ -441,19 +359,16 @@ type interfaceInvokeWrapper struct {
 // the underlying value, dereferences it, and calls the real method. This
 // wrapper is only needed when the interface value actually doesn't fit in a
 // pointer and a pointer to the value must be created.
-func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) (llvm.Value, error) {
+func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	wrapperName := f.LinkName() + "$invoke"
 	wrapper := c.mod.NamedFunction(wrapperName)
 	if !wrapper.IsNil() {
 		// Wrapper already created. Return it directly.
-		return wrapper, nil
+		return wrapper
 	}
 
 	// Get the expanded receiver type.
-	receiverType, err := c.getLLVMType(f.Params[0].Type())
-	if err != nil {
-		return llvm.Value{}, err
-	}
+	receiverType := c.getLLVMType(f.Params[0].Type())
 	expandedReceiverType := c.expandFormalParamType(receiverType)
 
 	// Does this method even need any wrapping?
@@ -462,7 +377,7 @@ func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) (llvm.Value, error)
 		// 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, nil
+		return f.LLVMFn
 	}
 
 	// create wrapper function
@@ -475,12 +390,12 @@ func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) (llvm.Value, error)
 		wrapper:      wrapper,
 		receiverType: receiverType,
 	})
-	return wrapper, nil
+	return wrapper
 }
 
 // createInterfaceInvokeWrapper finishes the work of getInterfaceInvokeWrapper,
 // see that function for details.
-func (c *Compiler) createInterfaceInvokeWrapper(state interfaceInvokeWrapper) error {
+func (c *Compiler) createInterfaceInvokeWrapper(state interfaceInvokeWrapper) {
 	wrapper := state.wrapper
 	fn := state.fn
 	receiverType := state.receiverType
@@ -490,10 +405,7 @@ func (c *Compiler) createInterfaceInvokeWrapper(state interfaceInvokeWrapper) er
 	// add debug info if needed
 	if c.Debug {
 		pos := c.ir.Program.Fset.Position(fn.Pos())
-		difunc, err := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
-		if err != nil {
-			return err
-		}
+		difunc := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
 		c.builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 	}
 
@@ -501,28 +413,7 @@ func (c *Compiler) createInterfaceInvokeWrapper(state interfaceInvokeWrapper) er
 	block := c.ctx.AddBasicBlock(wrapper, "entry")
 	c.builder.SetInsertPointAtEnd(block)
 
-	var receiverPtr llvm.Value
-	if c.targetData.TypeAllocSize(receiverType) > c.targetData.TypeAllocSize(c.i8ptrType) {
-		// The receiver is passed in using a pointer. We have to load it here
-		// and pass it by value to the real function.
-
-		// Load the underlying value.
-		receiverPtrType := llvm.PointerType(receiverType, 0)
-		receiverPtr = c.builder.CreateBitCast(wrapper.Param(0), receiverPtrType, "receiver.ptr")
-	} else {
-		// The value is stored in the interface, but it is of type struct which
-		// is expanded to multiple parameters (e.g. {i8, i8}). So we have to
-		// receive the struct as parameter, expand it, and pass it on to the
-		// real function.
-
-		// Cast the passed-in i8* to the struct value (using an alloca) and
-		// extract its values.
-		alloca := c.builder.CreateAlloca(c.i8ptrType, "receiver.alloca")
-		c.builder.CreateStore(wrapper.Param(0), alloca)
-		receiverPtr = c.builder.CreateBitCast(alloca, llvm.PointerType(receiverType, 0), "receiver.ptr")
-	}
-
-	receiverValue := c.builder.CreateLoad(receiverPtr, "receiver")
+	receiverValue := c.emitPointerUnpack(wrapper.Param(0), []llvm.Type{receiverType})[0]
 	params := append(c.expandFormalParam(receiverValue), wrapper.Params()[1:]...)
 	if fn.LLVMFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
 		c.builder.CreateCall(fn.LLVMFn, params, "")
@@ -531,6 +422,4 @@ func (c *Compiler) createInterfaceInvokeWrapper(state interfaceInvokeWrapper) er
 		ret := c.builder.CreateCall(fn.LLVMFn, params, "ret")
 		c.builder.CreateRet(ret)
 	}
-
-	return nil
 }

compiler/llvm.go

@@ -22,6 +22,65 @@ func getUses(value llvm.Value) []llvm.Value {
 	return uses
 }
 
+// createEntryBlockAlloca creates a new alloca in the entry block, even though
+// the IR builder is located elsewhere. It assumes that the insert point is
+// at the end of the current block.
+func (c *Compiler) createEntryBlockAlloca(t llvm.Type, name string) llvm.Value {
+	currentBlock := c.builder.GetInsertBlock()
+	entryBlock := currentBlock.Parent().EntryBasicBlock()
+	if entryBlock.FirstInstruction().IsNil() {
+		c.builder.SetInsertPointAtEnd(entryBlock)
+	} else {
+		c.builder.SetInsertPointBefore(entryBlock.FirstInstruction())
+	}
+	alloca := c.builder.CreateAlloca(t, name)
+	c.builder.SetInsertPointAtEnd(currentBlock)
+	return alloca
+}
+
+// createTemporaryAlloca creates a new alloca in the entry block and adds
+// lifetime start infromation in the IR signalling that the alloca won't be used
+// before this point.
+//
+// This is useful for creating temporary allocas for intrinsics. Don't forget to
+// end the lifetime using emitLifetimeEnd after you're done with it.
+func (c *Compiler) createTemporaryAlloca(t llvm.Type, name string) (alloca, bitcast, size llvm.Value) {
+	alloca = c.createEntryBlockAlloca(t, name)
+	bitcast = c.builder.CreateBitCast(alloca, c.i8ptrType, name+".bitcast")
+	size = llvm.ConstInt(c.ctx.Int64Type(), c.targetData.TypeAllocSize(t), false)
+	c.builder.CreateCall(c.getLifetimeStartFunc(), []llvm.Value{size, bitcast}, "")
+	return
+}
+
+// emitLifetimeEnd signals the end of an (alloca) lifetime by calling the
+// llvm.lifetime.end intrinsic. It is commonly used together with
+// createTemporaryAlloca.
+func (c *Compiler) emitLifetimeEnd(ptr, size llvm.Value) {
+	c.builder.CreateCall(c.getLifetimeEndFunc(), []llvm.Value{size, ptr}, "")
+}
+
+// getLifetimeStartFunc returns the llvm.lifetime.start intrinsic and creates it
+// first if it doesn't exist yet.
+func (c *Compiler) getLifetimeStartFunc() llvm.Value {
+	fn := c.mod.NamedFunction("llvm.lifetime.start.p0i8")
+	if fn.IsNil() {
+		fnType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.ctx.Int64Type(), c.i8ptrType}, false)
+		fn = llvm.AddFunction(c.mod, "llvm.lifetime.start.p0i8", fnType)
+	}
+	return fn
+}
+
+// getLifetimeEndFunc returns the llvm.lifetime.end intrinsic and creates it
+// first if it doesn't exist yet.
+func (c *Compiler) getLifetimeEndFunc() llvm.Value {
+	fn := c.mod.NamedFunction("llvm.lifetime.end.p0i8")
+	if fn.IsNil() {
+		fnType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.ctx.Int64Type(), c.i8ptrType}, false)
+		fn = llvm.AddFunction(c.mod, "llvm.lifetime.end.p0i8", fnType)
+	}
+	return fn
+}
+
 // splitBasicBlock splits a LLVM basic block into two parts. All instructions
 // after afterInst are moved into a new basic block (created right after the
 // current one) with the given name.

compiler/map.go

@@ -10,12 +10,14 @@ import (
 )
 
 func (c *Compiler) emitMapLookup(keyType, valueType types.Type, m, key llvm.Value, commaOk bool, pos token.Pos) (llvm.Value, error) {
-	llvmValueType, err := c.getLLVMType(valueType)
-	if err != nil {
-		return llvm.Value{}, err
-	}
-	mapValueAlloca := c.builder.CreateAlloca(llvmValueType, "hashmap.value")
-	mapValuePtr := c.builder.CreateBitCast(mapValueAlloca, c.i8ptrType, "hashmap.valueptr")
+	llvmValueType := c.getLLVMType(valueType)
+
+	// Allocate the memory for the resulting type. Do not zero this memory: it
+	// will be zeroed by the hashmap get implementation if the key is not
+	// present in the map.
+	mapValueAlloca, mapValuePtr, mapValueSize := c.createTemporaryAlloca(llvmValueType, "hashmap.value")
+
+	// Do the lookup. How it is done depends on the key type.
 	var commaOkValue llvm.Value
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
@@ -23,15 +25,24 @@ func (c *Compiler) emitMapLookup(keyType, valueType types.Type, m, key llvm.Valu
 		commaOkValue = c.createRuntimeCall("hashmapStringGet", params, "")
 	} else if hashmapIsBinaryKey(keyType) {
 		// key can be compared with runtime.memequal
-		keyAlloca := c.builder.CreateAlloca(key.Type(), "hashmap.key")
-		c.builder.CreateStore(key, keyAlloca)
-		keyPtr := c.builder.CreateBitCast(keyAlloca, c.i8ptrType, "hashmap.keyptr")
-		params := []llvm.Value{m, keyPtr, mapValuePtr}
+		// Store the key in an alloca, in the entry block to avoid dynamic stack
+		// growth.
+		mapKeyAlloca, mapKeyPtr, mapKeySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
+		c.builder.CreateStore(key, mapKeyAlloca)
+		// Fetch the value from the hashmap.
+		params := []llvm.Value{m, mapKeyPtr, mapValuePtr}
 		commaOkValue = c.createRuntimeCall("hashmapBinaryGet", params, "")
+		c.emitLifetimeEnd(mapKeyPtr, mapKeySize)
 	} else {
+		// Not trivially comparable using memcmp.
 		return llvm.Value{}, c.makeError(pos, "only strings, bools, ints or structs of bools/ints are supported as map keys, but got: "+keyType.String())
 	}
+
+	// Load the resulting value from the hashmap. The value is set to the zero
+	// value if the key doesn't exist in the hashmap.
 	mapValue := c.builder.CreateLoad(mapValueAlloca, "")
+	c.emitLifetimeEnd(mapValuePtr, mapValueSize)
+
 	if commaOk {
 		tuple := llvm.Undef(c.ctx.StructType([]llvm.Type{llvmValueType, c.ctx.Int1Type()}, false))
 		tuple = c.builder.CreateInsertValue(tuple, mapValue, 0, "")
@@ -42,27 +53,25 @@ func (c *Compiler) emitMapLookup(keyType, valueType types.Type, m, key llvm.Valu
 	}
 }
 
-func (c *Compiler) emitMapUpdate(keyType types.Type, m, key, value llvm.Value, pos token.Pos) error {
-	valueAlloca := c.builder.CreateAlloca(value.Type(), "hashmap.value")
+func (c *Compiler) emitMapUpdate(keyType types.Type, m, key, value llvm.Value, pos token.Pos) {
+	valueAlloca, valuePtr, valueSize := c.createTemporaryAlloca(value.Type(), "hashmap.value")
 	c.builder.CreateStore(value, valueAlloca)
-	valuePtr := c.builder.CreateBitCast(valueAlloca, c.i8ptrType, "hashmap.valueptr")
 	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
 		params := []llvm.Value{m, key, valuePtr}
 		c.createRuntimeCall("hashmapStringSet", params, "")
-		return nil
 	} else if hashmapIsBinaryKey(keyType) {
 		// key can be compared with runtime.memequal
-		keyAlloca := c.builder.CreateAlloca(key.Type(), "hashmap.key")
+		keyAlloca, keyPtr, keySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
 		c.builder.CreateStore(key, keyAlloca)
-		keyPtr := c.builder.CreateBitCast(keyAlloca, c.i8ptrType, "hashmap.keyptr")
 		params := []llvm.Value{m, keyPtr, valuePtr}
 		c.createRuntimeCall("hashmapBinarySet", params, "")
-		return nil
+		c.emitLifetimeEnd(keyPtr, keySize)
 	} else {
-		return c.makeError(pos, "only strings, bools, ints or structs of bools/ints are supported as map keys, but got: "+keyType.String())
+		c.addError(pos, "only strings, bools, ints or structs of bools/ints are supported as map keys, but got: "+keyType.String())
 	}
+	c.emitLifetimeEnd(valuePtr, valueSize)
 }
 
 func (c *Compiler) emitMapDelete(keyType types.Type, m, key llvm.Value, pos token.Pos) error {
@@ -73,11 +82,11 @@ func (c *Compiler) emitMapDelete(keyType types.Type, m, key llvm.Value, pos toke
 		c.createRuntimeCall("hashmapStringDelete", params, "")
 		return nil
 	} else if hashmapIsBinaryKey(keyType) {
-		keyAlloca := c.builder.CreateAlloca(key.Type(), "hashmap.key")
+		keyAlloca, keyPtr, keySize := c.createTemporaryAlloca(key.Type(), "hashmap.key")
 		c.builder.CreateStore(key, keyAlloca)
-		keyPtr := c.builder.CreateBitCast(keyAlloca, c.i8ptrType, "hashmap.keyptr")
 		params := []llvm.Value{m, keyPtr}
 		c.createRuntimeCall("hashmapBinaryDelete", params, "")
+		c.emitLifetimeEnd(keyPtr, keySize)
 		return nil
 	} else {
 		return c.makeError(pos, "only strings, bools, ints or structs of bools/ints are supported as map keys, but got: "+keyType.String())

compiler/optimizer.go

@@ -18,6 +18,10 @@ func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) erro
 	}
 	builder.AddCoroutinePassesToExtensionPoints()
 
+	if c.PanicStrategy == "trap" {
+		c.replacePanicsWithTrap() // -panic=trap
+	}
+
 	// Run function passes for each function.
 	funcPasses := llvm.NewFunctionPassManagerForModule(c.mod)
 	defer funcPasses.Dispose()
@@ -113,6 +117,25 @@ func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) erro
 	return nil
 }
 
+// Replace panic calls with calls to llvm.trap, to reduce code size. This is the
+// -panic=trap intrinsic.
+func (c *Compiler) replacePanicsWithTrap() {
+	trap := c.mod.NamedFunction("llvm.trap")
+	for _, name := range []string{"runtime._panic", "runtime.runtimePanic"} {
+		fn := c.mod.NamedFunction(name)
+		if fn.IsNil() {
+			continue
+		}
+		for _, use := range getUses(fn) {
+			if use.IsACallInst().IsNil() || use.CalledValue() != fn {
+				panic("expected use of a panic function to be a call")
+			}
+			c.builder.SetInsertPointBefore(use)
+			c.builder.CreateCall(trap, nil, "")
+		}
+	}
+}
+
 // Eliminate created but not used maps.
 //
 // In the future, this should statically allocate created but never modified
@@ -249,7 +272,7 @@ func (c *Compiler) OptimizeAllocs() {
 			sizeInWords := (size + uint64(alignment) - 1) / uint64(alignment)
 			allocaType := llvm.ArrayType(c.ctx.IntType(alignment*8), int(sizeInWords))
 			alloca := c.builder.CreateAlloca(allocaType, "stackalloc.alloca")
-			zero, _ := c.getZeroValue(alloca.Type().ElementType())
+			zero := c.getZeroValue(alloca.Type().ElementType())
 			c.builder.CreateStore(zero, alloca)
 			stackalloc := c.builder.CreateBitCast(alloca, bitcast.Type(), "stackalloc")
 			bitcast.ReplaceAllUsesWith(stackalloc)
@@ -284,18 +307,6 @@ func (c *Compiler) doesEscape(value llvm.Value) bool {
 				return true
 			}
 		} else if use.IsACallInst() != nilValue {
-			// Call only escapes when the (pointer) parameter is not marked
-			// "nocapture". This flag means that the parameter does not escape
-			// the give function.
-			if use.CalledValue().IsAFunction() != nilValue {
-				if use.CalledValue().IsDeclaration() {
-					// Kind of dirty: assume external functions don't let
-					// pointers escape.
-					// TODO: introduce //go:noescape that sets the 'nocapture'
-					// flag on each input parameter.
-					continue
-				}
-			}
 			if !c.hasFlag(use, value, "nocapture") {
 				return true
 			}

compiler/sizes.go

@@ -113,6 +113,9 @@ func (s *StdSizes) Sizeof(T types.Type) int64 {
 		if k == types.Uintptr {
 			return s.PtrSize
 		}
+		if k == types.UnsafePointer {
+			return s.PtrSize
+		}
 		panic("unknown basic type: " + t.String())
 	case *types.Array:
 		n := t.Len()

compiler/syscall.go

@@ -51,10 +51,7 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 				"{r12}",
 				"{r13}",
 			}[i]
-			llvmValue, err := c.parseExpr(frame, arg)
-			if err != nil {
-				return llvm.Value{}, err
-			}
+			llvmValue := c.getValue(frame, arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
@@ -80,10 +77,7 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 				"{r5}",
 				"{r6}",
 			}[i]
-			llvmValue, err := c.parseExpr(frame, arg)
-			if err != nil {
-				return llvm.Value{}, err
-			}
+			llvmValue := c.getValue(frame, arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
@@ -113,10 +107,7 @@ func (c *Compiler) emitSyscall(frame *Frame, call *ssa.CallCommon) (llvm.Value,
 				"{x4}",
 				"{x5}",
 			}[i]
-			llvmValue, err := c.parseExpr(frame, arg)
-			if err != nil {
-				return llvm.Value{}, err
-			}
+			llvmValue := c.getValue(frame, arg)
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}

compiler/volatile.go

@@ -0,0 +1,26 @@
+package compiler
+
+// This file implements volatile loads/stores in runtime/volatile.LoadT and
+// runtime/volatile.StoreT as compiler builtins.
+
+import (
+	"golang.org/x/tools/go/ssa"
+	"tinygo.org/x/go-llvm"
+)
+
+func (c *Compiler) emitVolatileLoad(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) {
+	addr := c.getValue(frame, instr.Args[0])
+	c.emitNilCheck(frame, addr, "deref")
+	val := c.builder.CreateLoad(addr, "")
+	val.SetVolatile(true)
+	return val, nil
+}
+
+func (c *Compiler) emitVolatileStore(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) {
+	addr := c.getValue(frame, instr.Args[0])
+	val := c.getValue(frame, instr.Args[1])
+	c.emitNilCheck(frame, addr, "deref")
+	store := c.builder.CreateStore(val, addr)
+	store.SetVolatile(true)
+	return llvm.Value{}, nil
+}

compiler/wordpack.go

@@ -0,0 +1,117 @@
+package compiler
+
+// This file contains utility functions to pack and unpack sets of values. It
+// can take in a list of values and tries to store it efficiently in the pointer
+// itself if possible and legal.
+
+import (
+	"tinygo.org/x/go-llvm"
+)
+
+// emitPointerPack packs the list of values into a single pointer value using
+// bitcasts, or else allocates a value on the heap if it cannot be packed in the
+// pointer value directly. It returns the pointer with the packed data.
+func (c *Compiler) emitPointerPack(values []llvm.Value) llvm.Value {
+	valueTypes := make([]llvm.Type, len(values))
+	for i, value := range values {
+		valueTypes[i] = value.Type()
+	}
+	packedType := c.ctx.StructType(valueTypes, false)
+
+	// Allocate memory for the packed data.
+	var packedAlloc, packedHeapAlloc llvm.Value
+	size := c.targetData.TypeAllocSize(packedType)
+	if size == 0 {
+		return llvm.ConstPointerNull(c.i8ptrType)
+	} else if len(values) == 1 && values[0].Type().TypeKind() == llvm.PointerTypeKind {
+		return c.builder.CreateBitCast(values[0], c.i8ptrType, "pack.ptr")
+	} else if size <= c.targetData.TypeAllocSize(c.i8ptrType) {
+		// Packed data fits in a pointer, so store it directly inside the
+		// pointer.
+		if len(values) == 1 && values[0].Type().TypeKind() == llvm.IntegerTypeKind {
+			// Try to keep this cast in SSA form.
+			return c.builder.CreateIntToPtr(values[0], c.i8ptrType, "pack.int")
+		}
+		// Because packedType is a struct and we have to cast it to a *i8, store
+		// it in an alloca first for bitcasting (store+bitcast+load).
+		packedAlloc, _, _ = c.createTemporaryAlloca(packedType, "")
+	} else {
+		// Packed data is bigger than a pointer, so allocate it on the heap.
+		sizeValue := llvm.ConstInt(c.uintptrType, size, false)
+		packedHeapAlloc = c.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "")
+		packedAlloc = c.builder.CreateBitCast(packedHeapAlloc, llvm.PointerType(packedType, 0), "")
+	}
+	// Store all values in the alloca or heap pointer.
+	for i, value := range values {
+		indices := []llvm.Value{
+			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false),
+		}
+		gep := c.builder.CreateInBoundsGEP(packedAlloc, indices, "")
+		c.builder.CreateStore(value, gep)
+	}
+
+	if packedHeapAlloc.IsNil() {
+		// Load value (as *i8) from the alloca.
+		packedAlloc = c.builder.CreateBitCast(packedAlloc, llvm.PointerType(c.i8ptrType, 0), "")
+		result := c.builder.CreateLoad(packedAlloc, "")
+		packedPtr := c.builder.CreateBitCast(packedAlloc, c.i8ptrType, "")
+		packedSize := llvm.ConstInt(c.ctx.Int64Type(), c.targetData.TypeAllocSize(packedAlloc.Type()), false)
+		c.emitLifetimeEnd(packedPtr, packedSize)
+		return result
+	} else {
+		// Get the original heap allocation pointer, which already is an *i8.
+		return packedHeapAlloc
+	}
+}
+
+// emitPointerUnpack extracts a list of values packed using emitPointerPack.
+func (c *Compiler) emitPointerUnpack(ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
+	packedType := c.ctx.StructType(valueTypes, false)
+
+	// Get a correctly-typed pointer to the packed data.
+	var packedAlloc, packedRawAlloc llvm.Value
+	size := c.targetData.TypeAllocSize(packedType)
+	if size == 0 {
+		// No data to unpack.
+	} else if len(valueTypes) == 1 && valueTypes[0].TypeKind() == llvm.PointerTypeKind {
+		// A single pointer is always stored directly.
+		return []llvm.Value{c.builder.CreateBitCast(ptr, valueTypes[0], "unpack.ptr")}
+	} else if size <= c.targetData.TypeAllocSize(c.i8ptrType) {
+		// Packed data stored directly in pointer.
+		if len(valueTypes) == 1 && valueTypes[0].TypeKind() == llvm.IntegerTypeKind {
+			// Keep this cast in SSA form.
+			return []llvm.Value{c.builder.CreatePtrToInt(ptr, valueTypes[0], "unpack.int")}
+		}
+		// Fallback: load it using an alloca.
+		packedRawAlloc, _, _ = c.createTemporaryAlloca(llvm.PointerType(c.i8ptrType, 0), "unpack.raw.alloc")
+		packedRawValue := c.builder.CreateBitCast(ptr, llvm.PointerType(c.i8ptrType, 0), "unpack.raw.value")
+		c.builder.CreateStore(packedRawValue, packedRawAlloc)
+		packedAlloc = c.builder.CreateBitCast(packedRawAlloc, llvm.PointerType(packedType, 0), "unpack.alloc")
+	} else {
+		// Packed data stored on the heap. Bitcast the passed-in pointer to the
+		// correct pointer type.
+		packedAlloc = c.builder.CreateBitCast(ptr, llvm.PointerType(packedType, 0), "unpack.raw.ptr")
+	}
+	// Load each value from the packed data.
+	values := make([]llvm.Value, len(valueTypes))
+	for i, valueType := range valueTypes {
+		if c.targetData.TypeAllocSize(valueType) == 0 {
+			// This value has length zero, so there's nothing to load.
+			values[i] = c.getZeroValue(valueType)
+			continue
+		}
+		indices := []llvm.Value{
+			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(c.ctx.Int32Type(), uint64(i), false),
+		}
+		gep := c.builder.CreateInBoundsGEP(packedAlloc, indices, "")
+		values[i] = c.builder.CreateLoad(gep, "")
+	}
+	if !packedRawAlloc.IsNil() {
+		allocPtr := c.builder.CreateBitCast(packedRawAlloc, c.i8ptrType, "")
+		allocSize := llvm.ConstInt(c.ctx.Int64Type(), c.targetData.TypeAllocSize(c.uintptrType), false)
+		c.emitLifetimeEnd(allocPtr, allocSize)
+	}
+	return values
+}

go.mod

@@ -0,0 +1,10 @@
+module github.com/tinygo-org/tinygo
+
+go 1.11
+
+require (
+	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
+	github.com/marcinbor85/gohex v0.0.0-20180128172054-7a43cd876e46
+	golang.org/x/tools v0.0.0-20190227180812-8dcc6e70cdef
+	tinygo.org/x/go-llvm v0.0.0-20190224120431-7707ae5d1261
+)

go.sum

@@ -0,0 +1,14 @@
+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/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+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=
+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/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+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=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+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=

interp/frame.go

@@ -184,6 +184,25 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 			lhs := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
 			rhs := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
 			predicate := inst.IntPredicate()
+			if predicate == llvm.IntEQ && lhs.Type().TypeKind() == llvm.PointerTypeKind {
+				// Unfortunately, the const propagation in the IR builder
+				// doesn't handle pointer compares of inttoptr values. So we
+				// implement it manually here.
+				lhsNil, ok1 := isPointerNil(lhs)
+				rhsNil, ok2 := isPointerNil(rhs)
+				if ok1 && ok2 {
+					if lhsNil && rhsNil {
+						// Both are nil, so this icmp is always evaluated to true.
+						fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), 1, false)}
+						continue
+					}
+					if lhsNil != rhsNil {
+						// Only one of them is nil, so this comparison must return false.
+						fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), 0, false)}
+						continue
+					}
+				}
+			}
 			fr.locals[inst] = &LocalValue{fr.Eval, fr.builder.CreateICmp(predicate, lhs, rhs, "")}
 		case !inst.IsAFCmpInst().IsNil():
 			lhs := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
@@ -347,6 +366,8 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int1Type(), implements, false)}
 			case callee.Name() == "runtime.nanotime":
 				fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstInt(fr.Mod.Context().Int64Type(), 0, false)}
+			case callee.Name() == "llvm.dbg.value":
+				// do nothing
 			case strings.HasPrefix(callee.Name(), "runtime.print") || callee.Name() == "runtime._panic":
 				// This are all print instructions, which necessarily have side
 				// effects but no results.
@@ -459,17 +480,21 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 			}
 			thenBB := inst.Operand(1)
 			elseBB := inst.Operand(2)
-			if !cond.IsConstant() {
+			if !cond.IsAInstruction().IsNil() {
 				return nil, nil, errors.New("interp: branch on a non-constant")
-			} else {
-				switch cond.ZExtValue() {
-				case 0: // false
-					return nil, []llvm.Value{thenBB}, nil // then
-				case 1: // true
-					return nil, []llvm.Value{elseBB}, nil // else
-				default:
-					panic("branch was not true or false")
-				}
+			}
+			if !cond.IsAConstantExpr().IsNil() {
+				// This may happen when the instruction builder could not
+				// const-fold some instructions.
+				return nil, nil, errors.New("interp: branch on a non-const-propagated constant expression")
+			}
+			switch cond {
+			case llvm.ConstInt(fr.Mod.Context().Int1Type(), 0, false): // false
+				return nil, []llvm.Value{thenBB}, nil // then
+			case llvm.ConstInt(fr.Mod.Context().Int1Type(), 1, false): // true
+				return nil, []llvm.Value{elseBB}, nil // else
+			default:
+				panic("branch was not true or false")
 			}
 		case !inst.IsABranchInst().IsNil() && inst.OperandsCount() == 1:
 			// unconditional branch (goto)

interp/interp.go

@@ -18,7 +18,6 @@ type Eval struct {
 	TargetData      llvm.TargetData
 	Debug           bool
 	builder         llvm.Builder
-	dibuilder       *llvm.DIBuilder
 	dirtyGlobals    map[llvm.Value]struct{}
 	sideEffectFuncs map[llvm.Value]*sideEffectResult // cache of side effect scan results
 }
@@ -38,7 +37,6 @@ func Run(mod llvm.Module, targetData llvm.TargetData, debug bool) error {
 		dirtyGlobals: map[llvm.Value]struct{}{},
 	}
 	e.builder = mod.Context().NewBuilder()
-	e.dibuilder = llvm.NewDIBuilder(mod)
 
 	initAll := mod.NamedFunction(name)
 	bb := initAll.EntryBasicBlock()
@@ -49,7 +47,6 @@ func Run(mod llvm.Module, targetData llvm.TargetData, debug bool) error {
 	e.builder.SetInsertPointBefore(bb.FirstInstruction())
 	dummy := e.builder.CreateAlloca(e.Mod.Context().Int8Type(), "dummy")
 	e.builder.SetInsertPointBefore(dummy)
-	e.builder.SetInstDebugLocation(bb.FirstInstruction())
 	var initCalls []llvm.Value
 	for inst := bb.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
 		if inst == dummy {

interp/scan.go

@@ -35,6 +35,8 @@ func (e *Eval) hasSideEffects(fn llvm.Value) *sideEffectResult {
 		return &sideEffectResult{severity: sideEffectLimited}
 	case "runtime.interfaceImplements":
 		return &sideEffectResult{severity: sideEffectNone}
+	case "llvm.dbg.value":
+		return &sideEffectResult{severity: sideEffectNone}
 	}
 	if e.sideEffectFuncs == nil {
 		e.sideEffectFuncs = make(map[llvm.Value]*sideEffectResult)
@@ -107,7 +109,16 @@ func (e *Eval) hasSideEffects(fn llvm.Value) *sideEffectResult {
 				default:
 					panic("unreachable")
 				}
-			case llvm.Load, llvm.Store:
+			case llvm.Load:
+				if inst.IsVolatile() {
+					result.updateSeverity(sideEffectLimited)
+				}
+				if _, ok := e.dirtyGlobals[inst.Operand(0)]; ok {
+					if e.hasLocalSideEffects(dirtyLocals, inst) {
+						result.updateSeverity(sideEffectLimited)
+					}
+				}
+			case llvm.Store:
 				if inst.IsVolatile() {
 					result.updateSeverity(sideEffectLimited)
 				}

interp/utils.go

@@ -94,3 +94,29 @@ func isScalar(t llvm.Type) bool {
 		return false
 	}
 }
+
+// isPointerNil returns whether this is a nil pointer or not. The ok value
+// indicates whether the result is certain: if it is false the result boolean is
+// not valid.
+func isPointerNil(v llvm.Value) (result bool, ok bool) {
+	if !v.IsAConstantExpr().IsNil() {
+		switch v.Opcode() {
+		case llvm.IntToPtr:
+			// Whether a constant inttoptr is nil is easy to
+			// determine.
+			operand := v.Operand(0)
+			if operand.IsConstant() {
+				return operand.ZExtValue() == 0, true
+			}
+		case llvm.BitCast, llvm.GetElementPtr:
+			// These const instructions are just a kind of wrappers for the
+			// underlying pointer.
+			return isPointerNil(v.Operand(0))
+		}
+	}
+	if !v.IsAConstantPointerNull().IsNil() {
+		// A constant pointer null is always null, of course.
+		return true, true
+	}
+	return false, false // not valid
+}

ir/ir.go

@@ -33,11 +33,12 @@ type Program struct {
 type Function struct {
 	*ssa.Function
 	LLVMFn    llvm.Value
-	linkName  string // go:linkname, go:export, go:interrupt
-	exported  bool   // go:export
-	nobounds  bool   // go:nobounds
-	flag      bool   // used by dead code elimination
-	interrupt bool   // go:interrupt
+	linkName  string     // go:linkname, go:export, go:interrupt
+	exported  bool       // go:export
+	nobounds  bool       // go:nobounds
+	flag      bool       // used by dead code elimination
+	interrupt bool       // go:interrupt
+	inline    InlineType // go:inline
 }
 
 // Global variable, possibly constant.
@@ -69,7 +70,22 @@ type Interface struct {
 	Type *types.Interface
 }
 
-// Create and intialize a new *Program from a *ssa.Program.
+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
+)
+
+// Create and initialize a new *Program from a *ssa.Program.
 func NewProgram(lprogram *loader.Program, mainPath string) *Program {
 	comments := map[string]*ast.CommentGroup{}
 	for _, pkgInfo := range lprogram.Sorted() {
@@ -279,6 +295,8 @@ func (f *Function) parsePragmas() {
 				}
 				f.linkName = parts[1]
 				f.exported = true
+			case "//go:inline":
+				f.inline = InlineHint
 			case "//go:interrupt":
 				if len(parts) != 2 {
 					continue
@@ -332,6 +350,11 @@ func (f *Function) IsInterrupt() bool {
 	return f.interrupt
 }
 
+// Return the inline directive of this function.
+func (f *Function) Inline() InlineType {
+	return f.inline
+}
+
 // Return the link name for this function.
 func (f *Function) LinkName() string {
 	if f.linkName != "" {

linker-builtin.go

@@ -24,7 +24,7 @@ import "C"
 // This version uses the built-in linker when trying to use lld.
 func Link(linker string, flags ...string) error {
 	switch linker {
-	case "ld.lld", commands["ld.lld"]:
+	case "ld.lld":
 		flags = append([]string{"tinygo:" + linker}, flags...)
 		var cflag *C.char
 		buf := C.calloc(C.size_t(len(flags)), C.size_t(unsafe.Sizeof(cflag)))
@@ -39,7 +39,7 @@ func Link(linker string, flags ...string) error {
 			return errors.New("failed to link using built-in ld.lld")
 		}
 		return nil
-	case "wasm-ld", commands["wasm-ld"]:
+	case "wasm-ld":
 		flags = append([]string{"tinygo:" + linker}, flags...)
 		var cflag *C.char
 		buf := C.calloc(C.size_t(len(flags)), C.size_t(unsafe.Sizeof(cflag)))
@@ -57,6 +57,9 @@ func Link(linker string, flags ...string) error {
 		return nil
 	default:
 		// Fall back to external command.
+		if cmdNames, ok := commands[linker]; ok {
+			return execCommand(cmdNames, flags...)
+		}
 		cmd := exec.Command(linker, flags...)
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr

linker-external.go

@@ -14,6 +14,9 @@ import (
 //
 // This version always runs the linker as an external command.
 func Link(linker string, flags ...string) error {
+	if cmdNames, ok := commands[linker]; ok {
+		return execCommand(cmdNames, flags...)
+	}
 	cmd := exec.Command(linker, flags...)
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr

loader/cgo.go

@@ -1,458 +0,0 @@
-package loader
-
-// This file extracts the `import "C"` statement from the source and modifies
-// the AST for Cgo. It does not use libclang directly (see libclang.go).
-
-import (
-	"go/ast"
-	"go/token"
-	"sort"
-	"strconv"
-	"strings"
-
-	"golang.org/x/tools/go/ast/astutil"
-)
-
-// fileInfo holds all Cgo-related information of a given *ast.File.
-type fileInfo struct {
-	*ast.File
-	*Package
-	filename        string
-	functions       map[string]*functionInfo
-	globals         map[string]*globalInfo
-	typedefs        map[string]*typedefInfo
-	elaboratedTypes map[string]ast.Expr
-	importCPos      token.Pos
-}
-
-// functionInfo stores some information about a Cgo function found by libclang
-// and declared in the AST.
-type functionInfo struct {
-	args    []paramInfo
-	results *ast.FieldList
-}
-
-// paramInfo is a parameter of a Cgo function (see functionInfo).
-type paramInfo struct {
-	name     string
-	typeExpr ast.Expr
-}
-
-// typedefInfo contains information about a single typedef in C.
-type typedefInfo struct {
-	typeExpr ast.Expr
-}
-
-// globalInfo contains information about a declared global variable in C.
-type globalInfo struct {
-	typeExpr ast.Expr
-}
-
-// cgoAliases list type aliases between Go and C, for types that are equivalent
-// in both languages. See addTypeAliases.
-var cgoAliases = map[string]string{
-	"C.int8_t":    "int8",
-	"C.int16_t":   "int16",
-	"C.int32_t":   "int32",
-	"C.int64_t":   "int64",
-	"C.uint8_t":   "uint8",
-	"C.uint16_t":  "uint16",
-	"C.uint32_t":  "uint32",
-	"C.uint64_t":  "uint64",
-	"C.uintptr_t": "uintptr",
-}
-
-// cgoTypes lists some C types with ambiguous sizes that must be retrieved
-// somehow from C. This is done by adding some typedefs to get the size of each
-// type.
-const cgoTypes = `
-typedef signed char         _Cgo_schar;
-typedef unsigned char       _Cgo_uchar;
-typedef short               _Cgo_short;
-typedef unsigned short      _Cgo_ushort;
-typedef int                 _Cgo_int;
-typedef unsigned int        _Cgo_uint;
-typedef long                _Cgo_long;
-typedef unsigned long       _Cgo_ulong;
-typedef long long           _Cgo_longlong;
-typedef unsigned long long  _Cgo_ulonglong;
-`
-
-// processCgo extracts the `import "C"` statement from the AST, parses the
-// comment with libclang, and modifies the AST to use this information.
-func (p *Package) processCgo(filename string, f *ast.File, cflags []string) []error {
-	info := &fileInfo{
-		File:            f,
-		Package:         p,
-		filename:        filename,
-		functions:       map[string]*functionInfo{},
-		globals:         map[string]*globalInfo{},
-		typedefs:        map[string]*typedefInfo{},
-		elaboratedTypes: map[string]ast.Expr{},
-	}
-
-	// Find `import "C"` statements in the file.
-	for i := 0; i < len(f.Decls); i++ {
-		decl := f.Decls[i]
-		genDecl, ok := decl.(*ast.GenDecl)
-		if !ok {
-			continue
-		}
-		if len(genDecl.Specs) != 1 {
-			continue
-		}
-		spec, ok := genDecl.Specs[0].(*ast.ImportSpec)
-		if !ok {
-			continue
-		}
-		path, err := strconv.Unquote(spec.Path.Value)
-		if err != nil {
-			panic("could not parse import path: " + err.Error())
-		}
-		if path != "C" {
-			continue
-		}
-		cgoComment := genDecl.Doc.Text()
-
-		// Stored for later use by generated functions, to use a somewhat sane
-		// source location.
-		info.importCPos = spec.Path.ValuePos
-
-		pos := info.fset.PositionFor(genDecl.Doc.Pos(), true)
-		errs := info.parseFragment(cgoComment+cgoTypes, cflags, pos.Filename, pos.Line)
-		if errs != nil {
-			return errs
-		}
-
-		// Remove this import declaration.
-		f.Decls = append(f.Decls[:i], f.Decls[i+1:]...)
-		i--
-	}
-
-	// Print the AST, for debugging.
-	//ast.Print(p.fset, f)
-
-	// Declare functions found by libclang.
-	info.addFuncDecls()
-
-	// Declare stub function pointer values found by libclang.
-	info.addFuncPtrDecls()
-
-	// Declare globals found by libclang.
-	info.addVarDecls()
-
-	// Forward C types to Go types (like C.uint32_t -> uint32).
-	info.addTypeAliases()
-
-	// Add type declarations for C types, declared using typedef in C.
-	info.addTypedefs()
-
-	// Add elaborated types for C structs and unions.
-	info.addElaboratedTypes()
-
-	// Patch the AST to use the declared types and functions.
-	f = astutil.Apply(f, info.walker, nil).(*ast.File)
-
-	return nil
-}
-
-// addFuncDecls adds the C function declarations found by libclang in the
-// comment above the `import "C"` statement.
-func (info *fileInfo) addFuncDecls() {
-	// TODO: replace all uses of importCPos with the real locations from
-	// libclang.
-	names := make([]string, 0, len(info.functions))
-	for name := range info.functions {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	for _, name := range names {
-		fn := info.functions[name]
-		obj := &ast.Object{
-			Kind: ast.Fun,
-			Name: "C." + name,
-		}
-		args := make([]*ast.Field, len(fn.args))
-		decl := &ast.FuncDecl{
-			Name: &ast.Ident{
-				NamePos: info.importCPos,
-				Name:    "C." + name,
-				Obj:     obj,
-			},
-			Type: &ast.FuncType{
-				Func: info.importCPos,
-				Params: &ast.FieldList{
-					Opening: info.importCPos,
-					List:    args,
-					Closing: info.importCPos,
-				},
-				Results: fn.results,
-			},
-		}
-		obj.Decl = decl
-		for i, arg := range fn.args {
-			args[i] = &ast.Field{
-				Names: []*ast.Ident{
-					&ast.Ident{
-						NamePos: info.importCPos,
-						Name:    arg.name,
-						Obj: &ast.Object{
-							Kind: ast.Var,
-							Name: arg.name,
-							Decl: decl,
-						},
-					},
-				},
-				Type: arg.typeExpr,
-			}
-		}
-		info.Decls = append(info.Decls, decl)
-	}
-}
-
-// addFuncPtrDecls creates stub declarations of function pointer values. These
-// values will later be replaced with the real values in the compiler.
-// It adds code like the following to the AST:
-//
-//     var (
-//         C.add unsafe.Pointer
-//         C.mul unsafe.Pointer
-//         // ...
-//     )
-func (info *fileInfo) addFuncPtrDecls() {
-	gen := &ast.GenDecl{
-		TokPos: info.importCPos,
-		Tok:    token.VAR,
-		Lparen: info.importCPos,
-		Rparen: info.importCPos,
-	}
-	names := make([]string, 0, len(info.functions))
-	for name := range info.functions {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	for _, name := range names {
-		obj := &ast.Object{
-			Kind: ast.Typ,
-			Name: "C." + name + "$funcaddr",
-		}
-		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{&ast.Ident{
-				NamePos: info.importCPos,
-				Name:    "C." + name + "$funcaddr",
-				Obj:     obj,
-			}},
-			Type: &ast.SelectorExpr{
-				X: &ast.Ident{
-					NamePos: info.importCPos,
-					Name:    "unsafe",
-				},
-				Sel: &ast.Ident{
-					NamePos: info.importCPos,
-					Name:    "Pointer",
-				},
-			},
-		}
-		obj.Decl = valueSpec
-		gen.Specs = append(gen.Specs, valueSpec)
-	}
-	info.Decls = append(info.Decls, gen)
-}
-
-// addVarDecls declares external C globals in the Go source.
-// It adds code like the following to the AST:
-//
-//     var (
-//         C.globalInt  int
-//         C.globalBool bool
-//         // ...
-//     )
-func (info *fileInfo) addVarDecls() {
-	gen := &ast.GenDecl{
-		TokPos: info.importCPos,
-		Tok:    token.VAR,
-		Lparen: info.importCPos,
-		Rparen: info.importCPos,
-	}
-	names := make([]string, 0, len(info.globals))
-	for name := range info.globals {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	for _, name := range names {
-		global := info.globals[name]
-		obj := &ast.Object{
-			Kind: ast.Typ,
-			Name: "C." + name,
-		}
-		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{&ast.Ident{
-				NamePos: info.importCPos,
-				Name:    "C." + name,
-				Obj:     obj,
-			}},
-			Type: global.typeExpr,
-		}
-		obj.Decl = valueSpec
-		gen.Specs = append(gen.Specs, valueSpec)
-	}
-	info.Decls = append(info.Decls, gen)
-}
-
-// addTypeAliases aliases some built-in Go types with their equivalent C types.
-// It adds code like the following to the AST:
-//
-//     type (
-//         C.int8_t  = int8
-//         C.int16_t = int16
-//         // ...
-//     )
-func (info *fileInfo) addTypeAliases() {
-	aliasKeys := make([]string, 0, len(cgoAliases))
-	for key := range cgoAliases {
-		aliasKeys = append(aliasKeys, key)
-	}
-	sort.Strings(aliasKeys)
-	gen := &ast.GenDecl{
-		TokPos: info.importCPos,
-		Tok:    token.TYPE,
-		Lparen: info.importCPos,
-		Rparen: info.importCPos,
-	}
-	for _, typeName := range aliasKeys {
-		goTypeName := cgoAliases[typeName]
-		obj := &ast.Object{
-			Kind: ast.Typ,
-			Name: typeName,
-		}
-		typeSpec := &ast.TypeSpec{
-			Name: &ast.Ident{
-				NamePos: info.importCPos,
-				Name:    typeName,
-				Obj:     obj,
-			},
-			Assign: info.importCPos,
-			Type: &ast.Ident{
-				NamePos: info.importCPos,
-				Name:    goTypeName,
-			},
-		}
-		obj.Decl = typeSpec
-		gen.Specs = append(gen.Specs, typeSpec)
-	}
-	info.Decls = append(info.Decls, gen)
-}
-
-func (info *fileInfo) addTypedefs() {
-	gen := &ast.GenDecl{
-		TokPos: info.importCPos,
-		Tok:    token.TYPE,
-	}
-	names := make([]string, 0, len(info.typedefs))
-	for name := range info.typedefs {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	for _, name := range names {
-		typedef := info.typedefs[name]
-		typeName := "C." + name
-		if strings.HasPrefix(name, "_Cgo_") {
-			typeName = "C." + name[len("_Cgo_"):]
-		}
-		if _, ok := cgoAliases[typeName]; ok {
-			// This is a type that also exists in Go (defined in stdint.h).
-			continue
-		}
-		obj := &ast.Object{
-			Kind: ast.Typ,
-			Name: typeName,
-		}
-		typeSpec := &ast.TypeSpec{
-			Name: &ast.Ident{
-				NamePos: info.importCPos,
-				Name:    typeName,
-				Obj:     obj,
-			},
-			Type: typedef.typeExpr,
-		}
-		obj.Decl = typeSpec
-		gen.Specs = append(gen.Specs, typeSpec)
-	}
-	info.Decls = append(info.Decls, gen)
-}
-
-// addElaboratedTypes adds C elaborated types as aliases. These are the "struct
-// foo" or "union foo" types, often used in a typedef.
-//
-// See also:
-// https://en.cppreference.com/w/cpp/language/elaborated_type_specifier
-func (info *fileInfo) addElaboratedTypes() {
-	gen := &ast.GenDecl{
-		TokPos: info.importCPos,
-		Tok:    token.TYPE,
-	}
-	names := make([]string, 0, len(info.elaboratedTypes))
-	for name := range info.elaboratedTypes {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	for _, name := range names {
-		typ := info.elaboratedTypes[name]
-		typeName := "C.struct_" + name
-		obj := &ast.Object{
-			Kind: ast.Typ,
-			Name: typeName,
-		}
-		typeSpec := &ast.TypeSpec{
-			Name: &ast.Ident{
-				NamePos: info.importCPos,
-				Name:    typeName,
-				Obj:     obj,
-			},
-			Type: typ,
-		}
-		obj.Decl = typeSpec
-		gen.Specs = append(gen.Specs, typeSpec)
-	}
-	info.Decls = append(info.Decls, gen)
-}
-
-// walker replaces all "C".<something> expressions to literal "C.<something>"
-// expressions. Such expressions are impossible to write in Go (a dot cannot be
-// used in the middle of a name) so in practice all C identifiers live in a
-// separate namespace (no _Cgo_ hacks like in gc).
-func (info *fileInfo) walker(cursor *astutil.Cursor) bool {
-	switch node := cursor.Node().(type) {
-	case *ast.CallExpr:
-		fun, ok := node.Fun.(*ast.SelectorExpr)
-		if !ok {
-			return true
-		}
-		x, ok := fun.X.(*ast.Ident)
-		if !ok {
-			return true
-		}
-		if _, ok := info.functions[fun.Sel.Name]; ok && x.Name == "C" {
-			node.Fun = &ast.Ident{
-				NamePos: x.NamePos,
-				Name:    "C." + fun.Sel.Name,
-			}
-		}
-	case *ast.SelectorExpr:
-		x, ok := node.X.(*ast.Ident)
-		if !ok {
-			return true
-		}
-		if x.Name == "C" {
-			name := "C." + node.Sel.Name
-			if _, ok := info.functions[node.Sel.Name]; ok {
-				name += "$funcaddr"
-			}
-			cursor.Replace(&ast.Ident{
-				NamePos: x.NamePos,
-				Name:    name,
-			})
-		}
-	}
-	return true
-}

loader/libclang.go

@@ -1,446 +0,0 @@
-package loader
-
-// This file parses a fragment of C with libclang and stores the result for AST
-// modification. It does not touch the AST itself.
-
-import (
-	"go/ast"
-	"go/scanner"
-	"go/token"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"unsafe"
-)
-
-/*
-#include <clang-c/Index.h> // if this fails, install libclang-8-dev
-#include <stdlib.h>
-#include <stdint.h>
-
-// This struct should be ABI-compatible on all platforms (uintptr_t has the same
-// alignment etc. as void*) but does not include void* pointers that are not
-// always real pointers.
-// The Go garbage collector assumes that all non-nil pointer-typed integers are
-// actually pointers. This is not always true, as data[1] often contains 0x1,
-// which is clearly not a valid pointer. Usually the GC won't catch this issue,
-// but occasionally it will leading to a crash with a vague error message.
-typedef struct {
-	enum CXCursorKind kind;
-	int xdata;
-	uintptr_t data[3];
-} GoCXCursor;
-
-// Forwarding functions. They are implemented in libclang_stubs.c and forward to
-// the real functions without doing anything else, thus they are entirely
-// compatible with the versions without tinygo_ prefix. The only difference is
-// the CXCursor type, which has been replaced with GoCXCursor.
-GoCXCursor tinygo_clang_getTranslationUnitCursor(CXTranslationUnit tu);
-unsigned tinygo_clang_visitChildren(GoCXCursor parent, CXCursorVisitor visitor, CXClientData client_data);
-CXString tinygo_clang_getCursorSpelling(GoCXCursor c);
-enum CXCursorKind tinygo_clang_getCursorKind(GoCXCursor c);
-CXType tinygo_clang_getCursorType(GoCXCursor c);
-GoCXCursor tinygo_clang_getTypeDeclaration(CXType t);
-CXType tinygo_clang_getTypedefDeclUnderlyingType(GoCXCursor c);
-CXType tinygo_clang_getCursorResultType(GoCXCursor c);
-int tinygo_clang_Cursor_getNumArguments(GoCXCursor c);
-GoCXCursor tinygo_clang_Cursor_getArgument(GoCXCursor c, unsigned i);
-
-int tinygo_clang_globals_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
-int tinygo_clang_struct_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
-*/
-import "C"
-
-// refMap stores references to types, used for clang_visitChildren.
-var refMap RefMap
-
-var diagnosticSeverity = [...]string{
-	C.CXDiagnostic_Ignored: "ignored",
-	C.CXDiagnostic_Note:    "note",
-	C.CXDiagnostic_Warning: "warning",
-	C.CXDiagnostic_Error:   "error",
-	C.CXDiagnostic_Fatal:   "fatal",
-}
-
-func (info *fileInfo) parseFragment(fragment string, cflags []string, posFilename string, posLine int) []error {
-	index := C.clang_createIndex(0, 0)
-	defer C.clang_disposeIndex(index)
-
-	filenameC := C.CString(posFilename + "!cgo.c")
-	defer C.free(unsafe.Pointer(filenameC))
-
-	fragmentC := C.CString(fragment)
-	defer C.free(unsafe.Pointer(fragmentC))
-
-	unsavedFile := C.struct_CXUnsavedFile{
-		Filename: filenameC,
-		Length:   C.ulong(len(fragment)),
-		Contents: fragmentC,
-	}
-
-	// convert Go slice of strings to C array of strings.
-	cmdargsC := C.malloc(C.size_t(len(cflags)) * C.size_t(unsafe.Sizeof(uintptr(0))))
-	defer C.free(cmdargsC)
-	cmdargs := (*[1 << 16]*C.char)(cmdargsC)
-	for i, cflag := range cflags {
-		s := C.CString(cflag)
-		cmdargs[i] = s
-		defer C.free(unsafe.Pointer(s))
-	}
-
-	var unit C.CXTranslationUnit
-	errCode := C.clang_parseTranslationUnit2(
-		index,
-		filenameC,
-		(**C.char)(cmdargsC), C.int(len(cflags)), // command line args
-		&unsavedFile, 1, // unsaved files
-		C.CXTranslationUnit_None,
-		&unit)
-	if errCode != 0 {
-		panic("loader: failed to parse source with libclang")
-	}
-	defer C.clang_disposeTranslationUnit(unit)
-
-	if numDiagnostics := int(C.clang_getNumDiagnostics(unit)); numDiagnostics != 0 {
-		errs := []error{}
-		addDiagnostic := func(diagnostic C.CXDiagnostic) {
-			spelling := getString(C.clang_getDiagnosticSpelling(diagnostic))
-			severity := diagnosticSeverity[C.clang_getDiagnosticSeverity(diagnostic)]
-			location := C.clang_getDiagnosticLocation(diagnostic)
-			var file C.CXFile
-			var line C.unsigned
-			var column C.unsigned
-			var offset C.unsigned
-			C.clang_getExpansionLocation(location, &file, &line, &column, &offset)
-			filename := getString(C.clang_getFileName(file))
-			if filename == posFilename+"!cgo.c" {
-				// Adjust errors from the `import "C"` snippet.
-				// Note: doesn't adjust filenames inside the error message
-				// itself.
-				filename = posFilename
-				line += C.uint(posLine)
-				offset = 0 // hard to calculate
-			} else if filepath.IsAbs(filename) {
-				// Relative paths for readability, like other Go parser errors.
-				relpath, err := filepath.Rel(info.Program.Dir, filename)
-				if err == nil {
-					filename = relpath
-				}
-			}
-			errs = append(errs, &scanner.Error{
-				Pos: token.Position{
-					Filename: filename,
-					Offset:   int(offset),
-					Line:     int(line),
-					Column:   int(column),
-				},
-				Msg: severity + ": " + spelling,
-			})
-		}
-		for i := 0; i < numDiagnostics; i++ {
-			diagnostic := C.clang_getDiagnostic(unit, C.uint(i))
-			addDiagnostic(diagnostic)
-
-			// Child diagnostics (like notes on redefinitions).
-			diagnostics := C.clang_getChildDiagnostics(diagnostic)
-			for j := 0; j < int(C.clang_getNumDiagnosticsInSet(diagnostics)); j++ {
-				addDiagnostic(C.clang_getDiagnosticInSet(diagnostics, C.uint(j)))
-			}
-		}
-		return errs
-	}
-
-	ref := refMap.Put(info)
-	defer refMap.Remove(ref)
-	cursor := C.tinygo_clang_getTranslationUnitCursor(unit)
-	C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_globals_visitor), C.CXClientData(ref))
-
-	return nil
-}
-
-//export tinygo_clang_globals_visitor
-func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClientData) C.int {
-	info := refMap.Get(unsafe.Pointer(client_data)).(*fileInfo)
-	kind := C.tinygo_clang_getCursorKind(c)
-	switch kind {
-	case C.CXCursor_FunctionDecl:
-		name := getString(C.tinygo_clang_getCursorSpelling(c))
-		cursorType := C.tinygo_clang_getCursorType(c)
-		if C.clang_isFunctionTypeVariadic(cursorType) != 0 {
-			return C.CXChildVisit_Continue // not supported
-		}
-		numArgs := int(C.tinygo_clang_Cursor_getNumArguments(c))
-		fn := &functionInfo{}
-		info.functions[name] = fn
-		for i := 0; i < numArgs; i++ {
-			arg := C.tinygo_clang_Cursor_getArgument(c, C.uint(i))
-			argName := getString(C.tinygo_clang_getCursorSpelling(arg))
-			argType := C.clang_getArgType(cursorType, C.uint(i))
-			if argName == "" {
-				argName = "$" + strconv.Itoa(i)
-			}
-			fn.args = append(fn.args, paramInfo{
-				name:     argName,
-				typeExpr: info.makeASTType(argType),
-			})
-		}
-		resultType := C.tinygo_clang_getCursorResultType(c)
-		if resultType.kind != C.CXType_Void {
-			fn.results = &ast.FieldList{
-				List: []*ast.Field{
-					&ast.Field{
-						Type: info.makeASTType(resultType),
-					},
-				},
-			}
-		}
-	case C.CXCursor_TypedefDecl:
-		typedefType := C.tinygo_clang_getCursorType(c)
-		name := getString(C.clang_getTypedefName(typedefType))
-		underlyingType := C.tinygo_clang_getTypedefDeclUnderlyingType(c)
-		expr := info.makeASTType(underlyingType)
-		if strings.HasPrefix(name, "_Cgo_") {
-			expr := expr.(*ast.Ident)
-			typeSize := C.clang_Type_getSizeOf(underlyingType)
-			switch expr.Name {
-			// TODO: plain char (may be signed or unsigned)
-			case "C.schar", "C.short", "C.int", "C.long", "C.longlong":
-				switch typeSize {
-				case 1:
-					expr.Name = "int8"
-				case 2:
-					expr.Name = "int16"
-				case 4:
-					expr.Name = "int32"
-				case 8:
-					expr.Name = "int64"
-				}
-			case "C.uchar", "C.ushort", "C.uint", "C.ulong", "C.ulonglong":
-				switch typeSize {
-				case 1:
-					expr.Name = "uint8"
-				case 2:
-					expr.Name = "uint16"
-				case 4:
-					expr.Name = "uint32"
-				case 8:
-					expr.Name = "uint64"
-				}
-			}
-		}
-		info.typedefs[name] = &typedefInfo{
-			typeExpr: expr,
-		}
-	case C.CXCursor_VarDecl:
-		name := getString(C.tinygo_clang_getCursorSpelling(c))
-		cursorType := C.tinygo_clang_getCursorType(c)
-		info.globals[name] = &globalInfo{
-			typeExpr: info.makeASTType(cursorType),
-		}
-	}
-	return C.CXChildVisit_Continue
-}
-
-func getString(clangString C.CXString) (s string) {
-	rawString := C.clang_getCString(clangString)
-	s = C.GoString(rawString)
-	C.clang_disposeString(clangString)
-	return
-}
-
-// makeASTType return the ast.Expr for the given libclang type. In other words,
-// it converts a libclang type to a type in the Go AST.
-func (info *fileInfo) makeASTType(typ C.CXType) ast.Expr {
-	var typeName string
-	switch typ.kind {
-	case C.CXType_SChar:
-		typeName = "C.schar"
-	case C.CXType_UChar:
-		typeName = "C.uchar"
-	case C.CXType_Short:
-		typeName = "C.short"
-	case C.CXType_UShort:
-		typeName = "C.ushort"
-	case C.CXType_Int:
-		typeName = "C.int"
-	case C.CXType_UInt:
-		typeName = "C.uint"
-	case C.CXType_Long:
-		typeName = "C.long"
-	case C.CXType_ULong:
-		typeName = "C.ulong"
-	case C.CXType_LongLong:
-		typeName = "C.longlong"
-	case C.CXType_ULongLong:
-		typeName = "C.ulonglong"
-	case C.CXType_Bool:
-		typeName = "bool"
-	case C.CXType_Float, C.CXType_Double, C.CXType_LongDouble:
-		switch C.clang_Type_getSizeOf(typ) {
-		case 4:
-			typeName = "float32"
-		case 8:
-			typeName = "float64"
-		default:
-			// Don't do anything, rely on the fallback code to show a somewhat
-			// sensible error message like "undeclared name: C.long double".
-		}
-	case C.CXType_Complex:
-		switch C.clang_Type_getSizeOf(typ) {
-		case 8:
-			typeName = "complex64"
-		case 16:
-			typeName = "complex128"
-		}
-	case C.CXType_Pointer:
-		return &ast.StarExpr{
-			Star: info.importCPos,
-			X:    info.makeASTType(C.clang_getPointeeType(typ)),
-		}
-	case C.CXType_ConstantArray:
-		return &ast.ArrayType{
-			Lbrack: info.importCPos,
-			Len: &ast.BasicLit{
-				ValuePos: info.importCPos,
-				Kind:     token.INT,
-				Value:    strconv.FormatInt(int64(C.clang_getArraySize(typ)), 10),
-			},
-			Elt: info.makeASTType(C.clang_getElementType(typ)),
-		}
-	case C.CXType_FunctionProto:
-		// Be compatible with gc, which uses the *[0]byte type for function
-		// pointer types.
-		// Return type [0]byte because this is a function type, not a pointer to
-		// this function type.
-		return &ast.ArrayType{
-			Lbrack: info.importCPos,
-			Len: &ast.BasicLit{
-				ValuePos: info.importCPos,
-				Kind:     token.INT,
-				Value:    "0",
-			},
-			Elt: &ast.Ident{
-				NamePos: info.importCPos,
-				Name:    "byte",
-			},
-		}
-	case C.CXType_Typedef:
-		typedefName := getString(C.clang_getTypedefName(typ))
-		return &ast.Ident{
-			NamePos: info.importCPos,
-			Name:    "C." + typedefName,
-		}
-	case C.CXType_Elaborated:
-		underlying := C.clang_Type_getNamedType(typ)
-		switch underlying.kind {
-		case C.CXType_Record:
-			cursor := C.tinygo_clang_getTypeDeclaration(typ)
-			name := getString(C.tinygo_clang_getCursorSpelling(cursor))
-			// It is possible that this is a recursive definition, for example
-			// in linked lists (structs contain a pointer to the next element
-			// of the same type). If the name exists in info.elaboratedTypes,
-			// it is being processed, although it may not be fully defined yet.
-			if _, ok := info.elaboratedTypes[name]; !ok {
-				info.elaboratedTypes[name] = nil // predeclare (to avoid endless recursion)
-				info.elaboratedTypes[name] = info.makeASTType(underlying)
-			}
-			return &ast.Ident{
-				NamePos: info.importCPos,
-				Name:    "C.struct_" + name,
-			}
-		default:
-			panic("unknown elaborated type")
-		}
-	case C.CXType_Record:
-		cursor := C.tinygo_clang_getTypeDeclaration(typ)
-		fieldList := &ast.FieldList{
-			Opening: info.importCPos,
-			Closing: info.importCPos,
-		}
-		ref := refMap.Put(struct {
-			fieldList *ast.FieldList
-			info      *fileInfo
-		}{fieldList, info})
-		defer refMap.Remove(ref)
-		C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_struct_visitor), C.CXClientData(ref))
-		switch C.tinygo_clang_getCursorKind(cursor) {
-		case C.CXCursor_StructDecl:
-			return &ast.StructType{
-				Struct: info.importCPos,
-				Fields: fieldList,
-			}
-		case C.CXCursor_UnionDecl:
-			if len(fieldList.List) > 1 {
-				// Insert a special field at the front (of zero width) as a
-				// marker that this is struct is actually a union. This is done
-				// by giving the field a name that cannot be expressed directly
-				// in Go.
-				// Other parts of the compiler look at the first element in a
-				// struct (of size > 2) to know whether this is a union.
-				// Note that we don't have to insert it for single-element
-				// unions as they're basically equivalent to a struct.
-				unionMarker := &ast.Field{
-					Type: &ast.StructType{
-						Struct: info.importCPos,
-					},
-				}
-				unionMarker.Names = []*ast.Ident{
-					&ast.Ident{
-						NamePos: info.importCPos,
-						Name:    "C union",
-						Obj: &ast.Object{
-							Kind: ast.Var,
-							Name: "C union",
-							Decl: unionMarker,
-						},
-					},
-				}
-				fieldList.List = append([]*ast.Field{unionMarker}, fieldList.List...)
-			}
-			return &ast.StructType{
-				Struct: info.importCPos,
-				Fields: fieldList,
-			}
-		}
-	}
-	if typeName == "" {
-		// Fallback, probably incorrect but at least the error points to an odd
-		// type name.
-		typeName = "C." + getString(C.clang_getTypeSpelling(typ))
-	}
-	return &ast.Ident{
-		NamePos: info.importCPos,
-		Name:    typeName,
-	}
-}
-
-//export tinygo_clang_struct_visitor
-func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientData) C.int {
-	passed := refMap.Get(unsafe.Pointer(client_data)).(struct {
-		fieldList *ast.FieldList
-		info      *fileInfo
-	})
-	fieldList := passed.fieldList
-	info := passed.info
-	if C.tinygo_clang_getCursorKind(c) != C.CXCursor_FieldDecl {
-		panic("expected field inside cursor")
-	}
-	name := getString(C.tinygo_clang_getCursorSpelling(c))
-	typ := C.tinygo_clang_getCursorType(c)
-	field := &ast.Field{
-		Type: info.makeASTType(typ),
-	}
-	field.Names = []*ast.Ident{
-		&ast.Ident{
-			NamePos: info.importCPos,
-			Name:    name,
-			Obj: &ast.Object{
-				Kind: ast.Var,
-				Name: name,
-				Decl: field,
-			},
-		},
-	}
-	fieldList.List = append(fieldList.List, field)
-	return C.CXChildVisit_Continue
-}

loader/loader.go

@@ -10,6 +10,8 @@ import (
 	"os"
 	"path/filepath"
 	"sort"
+
+	"github.com/tinygo-org/tinygo/cgo"
 )
 
 // Program holds all packages and some metadata about the program as a whole.
@@ -22,6 +24,7 @@ type Program struct {
 	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
 }
 
@@ -299,12 +302,22 @@ func (p *Package) parseFiles() ([]*ast.File, error) {
 			fileErrs = append(fileErrs, err)
 			continue
 		}
-		errs := p.processCgo(path, f, append(p.CFlags, "-I"+p.Package.Dir))
+		files = append(files, f)
+	}
+	if len(p.CgoFiles) != 0 {
+		clangIncludes := ""
+		if _, err := os.Stat(filepath.Join(p.TINYGOROOT, "llvm", "tools", "clang", "lib", "Headers")); !os.IsNotExist(err) {
+			// Running from the source directory.
+			clangIncludes = filepath.Join(p.TINYGOROOT, "llvm", "tools", "clang", "lib", "Headers")
+		} else {
+			// Running from the installation directory.
+			clangIncludes = filepath.Join(p.TINYGOROOT, "lib", "clang", "include")
+		}
+		generated, errs := cgo.Process(files, p.Program.Dir, p.fset, append(p.CFlags, "-I"+p.Package.Dir, "-I"+clangIncludes))
 		if errs != nil {
 			fileErrs = append(fileErrs, errs...)
-			continue
 		}
-		files = append(files, f)
+		files = append(files, generated)
 	}
 	if len(fileErrs) != 0 {
 		return nil, Errors{p, fileErrs}
@@ -333,7 +346,7 @@ func (p *Package) importRecursively() error {
 	p.Importing = true
 	for _, to := range p.Package.Imports {
 		if to == "C" {
-			// Do Cgo processing in a later stage.
+			// Do CGo processing in a later stage.
 			continue
 		}
 		if _, ok := p.Imports[to]; ok {

main.go

@@ -33,16 +33,27 @@ func (e *commandError) Error() string {
 	return e.Msg + " " + e.File + ": " + e.Err.Error()
 }
 
+// multiError is a list of multiple errors (actually: diagnostics) returned
+// during LLVM IR generation.
+type multiError struct {
+	Errs []error
+}
+
+func (e *multiError) Error() string {
+	return e.Errs[0].Error()
+}
+
 type BuildConfig struct {
-	opt        string
-	gc         string
-	printIR    bool
-	dumpSSA    bool
-	debug      bool
-	printSizes string
-	cFlags     []string
-	ldFlags    []string
-	wasmAbi    string
+	opt           string
+	gc            string
+	panicStrategy string
+	printIR       bool
+	dumpSSA       bool
+	debug         bool
+	printSizes    string
+	cFlags        []string
+	ldFlags       []string
+	wasmAbi       string
 }
 
 // Helper function for Compiler object.
@@ -51,23 +62,51 @@ func Compile(pkgName, outpath string, spec *TargetSpec, config *BuildConfig, act
 		config.gc = spec.GC
 	}
 
-	// Append command line passed CFlags and LDFlags
-	spec.CFlags = append(spec.CFlags, config.cFlags...)
-	spec.LDFlags = append(spec.LDFlags, config.ldFlags...)
+	root := sourceDir()
 
+	// Merge and adjust CFlags.
+	cflags := append([]string{}, config.cFlags...)
+	for _, flag := range spec.CFlags {
+		cflags = append(cflags, strings.Replace(flag, "{root}", root, -1))
+	}
+
+	// Merge and adjust LDFlags.
+	ldflags := append([]string{}, config.ldFlags...)
+	for _, flag := range spec.LDFlags {
+		ldflags = append(ldflags, strings.Replace(flag, "{root}", root, -1))
+	}
+
+	goroot := getGoroot()
+	if goroot == "" {
+		return errors.New("cannot locate $GOROOT, please set it manually")
+	}
+	tags := spec.BuildTags
+	major, minor := getGorootVersion(goroot)
+	if major != 1 {
+		if major == 0 {
+			return errors.New("could not read version from GOROOT: " + goroot)
+		}
+		return fmt.Errorf("expected major version 1, got go%d.%d", major, minor)
+	}
+	for i := 1; i <= minor; i++ {
+		tags = append(tags, fmt.Sprintf("go1.%d", i))
+	}
 	compilerConfig := compiler.Config{
-		Triple:    spec.Triple,
-		CPU:       spec.CPU,
-		GOOS:      spec.GOOS,
-		GOARCH:    spec.GOARCH,
-		GC:        config.gc,
-		CFlags:    spec.CFlags,
-		LDFlags:   spec.LDFlags,
-		Debug:     config.debug,
-		DumpSSA:   config.dumpSSA,
-		RootDir:   sourceDir(),
-		GOPATH:    getGopath(),
-		BuildTags: spec.BuildTags,
+		Triple:        spec.Triple,
+		CPU:           spec.CPU,
+		Features:      spec.Features,
+		GOOS:          spec.GOOS,
+		GOARCH:        spec.GOARCH,
+		GC:            config.gc,
+		PanicStrategy: config.panicStrategy,
+		CFlags:        cflags,
+		LDFlags:       ldflags,
+		Debug:         config.debug,
+		DumpSSA:       config.dumpSSA,
+		TINYGOROOT:    root,
+		GOROOT:        goroot,
+		GOPATH:        getGopath(),
+		BuildTags:     tags,
 	}
 	c, err := compiler.NewCompiler(pkgName, compilerConfig)
 	if err != nil {
@@ -75,12 +114,15 @@ func Compile(pkgName, outpath string, spec *TargetSpec, config *BuildConfig, act
 	}
 
 	// Compile Go code to IR.
-	err = c.Compile(pkgName)
-	if err != nil {
-		return err
+	errs := c.Compile(pkgName)
+	if len(errs) != 0 {
+		if len(errs) == 1 {
+			return errs[0]
+		}
+		return &multiError{errs}
 	}
 	if config.printIR {
-		fmt.Println("Generated LLVM IR:")
+		fmt.Println("; Generated LLVM IR:")
 		fmt.Println(c.IR())
 	}
 	if err := c.Verify(); err != nil {
@@ -191,19 +233,20 @@ func Compile(pkgName, outpath string, spec *TargetSpec, config *BuildConfig, act
 		// Prepare link command.
 		executable := filepath.Join(dir, "main")
 		tmppath := executable // final file
-		ldflags := append(spec.LDFlags, "-o", executable, objfile, "-L", sourceDir())
+		ldflags := append(ldflags, "-o", executable, objfile, "-L", root)
 		if spec.RTLib == "compiler-rt" {
 			ldflags = append(ldflags, librt)
 		}
 
 		// Compile extra files.
 		for i, path := range spec.ExtraFiles {
+			abspath := filepath.Join(root, path)
 			outpath := filepath.Join(dir, "extra-"+strconv.Itoa(i)+"-"+filepath.Base(path)+".o")
-			cmd := exec.Command(spec.Compiler, append(spec.CFlags, "-c", "-o", outpath, path)...)
-			cmd.Stdout = os.Stdout
-			cmd.Stderr = os.Stderr
-			cmd.Dir = sourceDir()
-			err := cmd.Run()
+			cmdNames := []string{spec.Compiler}
+			if names, ok := commands[spec.Compiler]; ok {
+				cmdNames = names
+			}
+			err := execCommand(cmdNames, append(cflags, "-c", "-o", outpath, abspath)...)
 			if err != nil {
 				return &commandError{"failed to build", path, err}
 			}
@@ -215,11 +258,11 @@ func Compile(pkgName, outpath string, spec *TargetSpec, config *BuildConfig, act
 			for _, file := range pkg.CFiles {
 				path := filepath.Join(pkg.Package.Dir, file)
 				outpath := filepath.Join(dir, "pkg"+strconv.Itoa(i)+"-"+file+".o")
-				cmd := exec.Command(spec.Compiler, append(spec.CFlags, "-c", "-o", outpath, path)...)
-				cmd.Stdout = os.Stdout
-				cmd.Stderr = os.Stderr
-				cmd.Dir = sourceDir()
-				err := cmd.Run()
+				cmdNames := []string{spec.Compiler}
+				if names, ok := commands[spec.Compiler]; ok {
+					cmdNames = names
+				}
+				err := execCommand(cmdNames, append(cflags, "-c", "-o", outpath, path)...)
 				if err != nil {
 					return &commandError{"failed to build", path, err}
 				}
@@ -228,11 +271,7 @@ func Compile(pkgName, outpath string, spec *TargetSpec, config *BuildConfig, act
 		}
 
 		// Link the object files together.
-		if linker, ok := commands[spec.Linker]; ok {
-			err = Link(linker, ldflags...)
-		} else {
-			err = Link(spec.Linker, ldflags...)
-		}
+		err = Link(spec.Linker, ldflags...)
 		if err != nil {
 			return &commandError{"failed to link", executable, err}
 		}
@@ -496,6 +535,10 @@ func handleCompilerError(err error) {
 			for _, err := range errLoader.Errs {
 				fmt.Fprintln(os.Stderr, err)
 			}
+		} else if errMulti, ok := err.(*multiError); ok {
+			for _, err := range errMulti.Errs {
+				fmt.Fprintln(os.Stderr, err)
+			}
 		} else {
 			fmt.Fprintln(os.Stderr, "error:", err)
 		}
@@ -507,6 +550,7 @@ func main() {
 	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, dumb, marksweep)")
+	panicStrategy := flag.String("panic", "print", "panic strategy (abort, trap)")
 	printIR := flag.Bool("printir", false, "print LLVM IR")
 	dumpSSA := flag.Bool("dumpssa", false, "dump internal Go SSA")
 	target := flag.String("target", "", "LLVM target")
@@ -527,13 +571,14 @@ func main() {
 
 	flag.CommandLine.Parse(os.Args[2:])
 	config := &BuildConfig{
-		opt:        *opt,
-		gc:         *gc,
-		printIR:    *printIR,
-		dumpSSA:    *dumpSSA,
-		debug:      !*nodebug,
-		printSizes: *printSize,
-		wasmAbi:    *wasmAbi,
+		opt:           *opt,
+		gc:            *gc,
+		panicStrategy: *panicStrategy,
+		printIR:       *printIR,
+		dumpSSA:       *dumpSSA,
+		debug:         !*nodebug,
+		printSizes:    *printSize,
+		wasmAbi:       *wasmAbi,
 	}
 
 	if *cFlags != "" {
@@ -544,6 +589,12 @@ func main() {
 		config.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)
+	}
+
 	os.Setenv("CC", "clang -target="+*target)
 
 	switch command {

main_test.go

@@ -13,17 +13,19 @@ import (
 	"runtime"
 	"sort"
 	"testing"
+
+	"github.com/tinygo-org/tinygo/loader"
 )
 
 const TESTDATA = "testdata"
 
 func TestCompiler(t *testing.T) {
-	matches, err := filepath.Glob(TESTDATA + "/*.go")
+	matches, err := filepath.Glob(filepath.Join(TESTDATA, "*.go"))
 	if err != nil {
 		t.Fatal("could not read test files:", err)
 	}
 
-	dirMatches, err := filepath.Glob(TESTDATA + "/*/main.go")
+	dirMatches, err := filepath.Glob(filepath.Join(TESTDATA, "*", "main.go"))
 	if err != nil {
 		t.Fatal("could not read test packages:", err)
 	}
@@ -64,7 +66,7 @@ func TestCompiler(t *testing.T) {
 	if runtime.GOOS == "linux" {
 		t.Log("running tests for linux/arm...")
 		for _, path := range matches {
-			if path == "testdata/cgo/" {
+			if path == filepath.Join("testdata", "cgo")+string(filepath.Separator) {
 				continue // TODO: improve CGo
 			}
 			t.Run(path, func(t *testing.T) {
@@ -74,7 +76,7 @@ func TestCompiler(t *testing.T) {
 
 		t.Log("running tests for linux/arm64...")
 		for _, path := range matches {
-			if path == "testdata/cgo/" {
+			if path == filepath.Join("testdata", "cgo")+string(filepath.Separator) {
 				continue // TODO: improve CGo
 			}
 			t.Run(path, func(t *testing.T) {
@@ -84,7 +86,7 @@ func TestCompiler(t *testing.T) {
 
 		t.Log("running tests for WebAssembly...")
 		for _, path := range matches {
-			if path == "testdata/gc.go" {
+			if path == filepath.Join("testdata", "gc.go") {
 				continue // known to fail
 			}
 			t.Run(path, func(t *testing.T) {
@@ -97,7 +99,7 @@ func TestCompiler(t *testing.T) {
 func runTest(path, tmpdir string, target string, t *testing.T) {
 	// Get the expected output for this test.
 	txtpath := path[:len(path)-3] + ".txt"
-	if path[len(path)-1] == '/' {
+	if path[len(path)-1] == os.PathSeparator {
 		txtpath = path + "out.txt"
 	}
 	f, err := os.Open(txtpath)
@@ -121,7 +123,13 @@ func runTest(path, tmpdir string, target string, t *testing.T) {
 	binary := filepath.Join(tmpdir, "test")
 	err = Build("./"+path, binary, target, config)
 	if err != nil {
-		t.Log("failed to build:", err)
+		if errLoader, ok := err.(loader.Errors); ok {
+			for _, err := range errLoader.Errs {
+				t.Log("failed to build:", err)
+			}
+		} else {
+			t.Log("failed to build:", err)
+		}
 		t.Fail()
 		return
 	}

src/device/arm/cortexm.s

@@ -0,0 +1,21 @@
+.syntax unified
+
+.section .text.HardFault_Handler
+.global  HardFault_Handler
+.type    HardFault_Handler, %function
+HardFault_Handler:
+    // Put the old stack pointer in the first argument, for easy debugging. This
+    // is especially useful on Cortex-M0, which supports far fewer debug
+    // facilities.
+    mov r0, sp
+
+    // Load the default stack pointer from address 0 so that we can call normal
+    // functions again that expect a working stack. However, it will corrupt the
+    // old stack so the function below must not attempt to recover from this
+    // fault.
+    movs r3, #0
+    ldr r3, [r3]
+    mov sp, r3
+
+    // Continue handling this error in Go.
+    bl handleHardFault

src/examples/adc/adc.go

@@ -11,8 +11,8 @@ import (
 func main() {
 	machine.InitADC()
 
-	led := machine.GPIO{machine.LED}
-	led.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
 	sensor := machine.ADC{machine.ADC2}
 	sensor.Configure()

src/examples/blinky1/blinky1.go

@@ -8,8 +8,8 @@ import (
 )
 
 func main() {
-	led := machine.GPIO{machine.LED}
-	led.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	for {
 		led.Low()
 		time.Sleep(time.Millisecond * 500)

src/examples/blinky2/blinky2.go

@@ -16,8 +16,8 @@ func main() {
 }
 
 func led1() {
-	led := machine.GPIO{machine.LED}
-	led.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	led := machine.LED1
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	for {
 		println("+")
 		led.Low()
@@ -30,8 +30,8 @@ func led1() {
 }
 
 func led2() {
-	led := machine.GPIO{machine.LED2}
-	led.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	led := machine.LED2
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	for {
 		println("  +")
 		led.Low()

src/examples/button/button.go

@@ -7,14 +7,14 @@ import (
 
 // This example assumes that the button is connected to pin 8. Change the value
 // below to use a different pin.
-const buttonPin = 8
+const (
+	led    = machine.LED
+	button = machine.Pin(8)
+)
 
 func main() {
-	led := machine.GPIO{machine.LED}
-	led.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
-
-	button := machine.GPIO{buttonPin}
-	button.Configure(machine.GPIOConfig{Mode: machine.GPIO_INPUT})
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	button.Configure(machine.PinConfig{Mode: machine.PinInput})
 
 	for {
 		if button.Get() {

src/examples/button2/button2.go

@@ -8,29 +8,29 @@ import (
 // This example assumes that you are using the pca10040 board
 
 func main() {
-	led1 := machine.GPIO{machine.LED1}
-	led1.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	led1 := machine.LED1
+	led1.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
-	led2 := machine.GPIO{machine.LED2}
-	led2.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	led2 := machine.LED2
+	led2.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
-	led3 := machine.GPIO{machine.LED3}
-	led3.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	led3 := machine.LED3
+	led3.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
-	led4 := machine.GPIO{machine.LED4}
-	led4.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	led4 := machine.LED4
+	led4.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
-	button1 := machine.GPIO{machine.BUTTON1}
-	button1.Configure(machine.GPIOConfig{Mode: machine.GPIO_INPUT_PULLUP})
+	button1 := machine.BUTTON1
+	button1.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
 
-	button2 := machine.GPIO{machine.BUTTON2}
-	button2.Configure(machine.GPIOConfig{Mode: machine.GPIO_INPUT_PULLUP})
+	button2 := machine.BUTTON2
+	button2.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
 
-	button3 := machine.GPIO{machine.BUTTON3}
-	button3.Configure(machine.GPIOConfig{Mode: machine.GPIO_INPUT_PULLUP})
+	button3 := machine.BUTTON3
+	button3.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
 
-	button4 := machine.GPIO{machine.BUTTON4}
-	button4.Configure(machine.GPIOConfig{Mode: machine.GPIO_INPUT_PULLUP})
+	button4 := machine.BUTTON4
+	button4.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
 
 	for {
 		led1.Set(button1.Get())

src/examples/echo/echo.go

@@ -9,9 +9,9 @@ import (
 
 // change these to test a different UART or pins if available
 var (
-	uart       = machine.UART0
-	tx   uint8 = machine.UART_TX_PIN
-	rx   uint8 = machine.UART_RX_PIN
+	uart = machine.UART0
+	tx   = machine.UART_TX_PIN
+	rx   = machine.UART_RX_PIN
 )
 
 func main() {

src/examples/i2s/i2s.go

@@ -0,0 +1,25 @@
+// Example using the i2s hardware interface on the Adafruit Circuit Playground Express
+// to read data from the onboard MEMS microphone.
+//
+package main
+
+import (
+	"machine"
+)
+
+func main() {
+	machine.I2S0.Configure(machine.I2SConfig{
+		Mode:        machine.I2SModePDM,
+		ClockSource: machine.I2SClockSourceExternal,
+		Stereo:      true,
+	})
+
+	data := make([]uint32, 64)
+
+	for {
+		// get the next group of samples
+		machine.I2S0.Read(data)
+
+		println("data", data[0], data[1], data[2], data[4], "...")
+	}
+}

src/examples/mcp3008/mcp3008.go

@@ -8,19 +8,17 @@ import (
 	"time"
 )
 
-// CS_PIN is the pin used for Chip Select (CS). Change to whatever is in use on your board.
-const CS_PIN = 3
+// cs is the pin used for Chip Select (CS). Change to whatever is in use on your board.
+const cs = machine.Pin(3)
 
 var (
 	tx          []byte
 	rx          []byte
 	val, result uint16
-	cs          machine.GPIO
 )
 
 func main() {
-	cs = machine.GPIO{CS_PIN}
-	cs.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	cs.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
 	machine.SPI0.Configure(machine.SPIConfig{
 		Frequency: 4000000,

src/examples/microbit-blink/microbit-blink.go

@@ -1,4 +1,4 @@
-// blink program for the BBC micro:bit that uses the entire LED matrix
+// blink program for the BBC micro:bit
 package main
 
 import (
@@ -6,14 +6,19 @@ import (
 	"time"
 )
 
+// The LED matrix in the micro:bit is a multiplexed display: https://en.wikipedia.org/wiki/Multiplexed_display
+// Driver for easier control: https://github.com/tinygo-org/drivers/tree/master/microbitmatrix
 func main() {
-	machine.InitLEDMatrix()
-
+	ledrow := machine.LED_ROW_1
+	ledrow.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	ledcol := machine.LED_COL_1
+	ledcol.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	ledcol.Low()
 	for {
-		machine.ClearLEDMatrix()
+		ledrow.Low()
 		time.Sleep(time.Millisecond * 500)
 
-		machine.SetEntireLEDMatrixOn()
+		ledrow.High()
 		time.Sleep(time.Millisecond * 500)
 	}
 }

src/examples/wasm/Makefile

@@ -1,10 +1,15 @@
 export: clean wasm_exec
-	tinygo build -o ./html/wasm.wasm -target wasm ./export/wasm.go
+	tinygo build -o ./html/wasm.wasm -target wasm -no-debug ./export/wasm.go
 	cp ./export/wasm.js ./html/
 	cp ./export/index.html ./html/
 
+callback: clean wasm_exec
+	tinygo build -o ./html/wasm.wasm -target wasm ./callback/wasm.go
+	cp ./callback/wasm.js ./html/
+	cp ./callback/index.html ./html/
+
 main: clean wasm_exec
-	tinygo build -o ./html/wasm.wasm -target wasm ./main/main.go
+	tinygo build -o ./html/wasm.wasm -target wasm -no-debug ./main/main.go
 	cp ./main/index.html ./html/
 
 wasm_exec:

src/examples/wasm/README.md

@@ -1,6 +1,6 @@
 # TinyGo WebAssembly examples
 
-The examples here show two different ways of using WebAssembly with TinyGo;
+The examples here show two different ways of using WebAssembly with TinyGo:
 
 1. Defining and exporting functions via the `//go:export <name>` directive. See
 [the export folder](./export) for an example of this.
@@ -31,23 +31,31 @@ $ make main
 
 ## Running
 
-Start the local webserver:
+Start the local web server:
 
 ```bash
 $ go run main.go
 Serving ./html on http://localhost:8080
 ```
 
-`fmt.Println` prints to the browser console.
+Use your web browser to visit http://localhost:8080.
+
+* The wasm "export" example displays a simple math equation using HTML, with
+the result calculated dynamically using WebAssembly.  Changing any of the
+values on the left hand side triggers the exported wasm `update` function to
+recalculate the result.
+* The wasm "main" example uses `println` to write to your browser JavaScript
+console. You may need to open the browser development tools console to see it.
 
 ## How it works
 
-Execution of the contents require a few JS helper functions which are called
-from WebAssembly. We have defined these in
-[wasm_exec.js](../../../targets/wasm_exec.js). It is based on
-`$GOROOT/misc/wasm/wasm_exec.js` from the standard library, but is slightly
-different. Ensure you are using the same version of `wasm_exec.js` as the
-version of `tinygo` you are using to compile.
+Execution of the contents require a few JavaScript helper functions which are
+called from WebAssembly.
+
+We have defined these in [wasm_exec.js](../../../targets/wasm_exec.js).  It is
+based on `$GOROOT/misc/wasm/wasm_exec.js` from the standard library, but is
+slightly different. Ensure you are using the same version of `wasm_exec.js` as
+the version of `tinygo` you are using to compile.
 
 The general steps required to run the WebAssembly file in the browser includes
 loading it into JavaScript with `WebAssembly.instantiateStreaming`, or
@@ -80,8 +88,9 @@ If you have used explicit exports, you can call them by invoking them under the
 `wasm.exports` namespace. See the [`export`](./export/wasm.js) directory for an
 example of this.
 
-In addition to this piece of JavaScript, it is important that the file is served
-with the correct `Content-Type` header set.
+In addition to the JavaScript, it is important the wasm file is served with the
+[`Content-Type`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type)
+header set to `application/wasm`.  Without it, most browsers won't run it.
 
 ```go
 package main
@@ -98,14 +107,25 @@ func main() {
 	fs := http.FileServer(http.Dir(dir))
 	log.Print("Serving " + dir + " on http://localhost:8080")
 	http.ListenAndServe(":8080", http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+		resp.Header().Add("Cache-Control", "no-cache")
 		if strings.HasSuffix(req.URL.Path, ".wasm") {
 			resp.Header().Set("content-type", "application/wasm")
 		}
-
 		fs.ServeHTTP(resp, req)
-	}))
-}
+	}))}
 ```
 
-This simple server serves anything inside the `./html` directory on port `8080`,
-setting any `*.wasm` files `Content-Type` header appropriately.
+This simple server serves anything inside the `./html` directory on port
+`8080`, setting any `*.wasm` files `Content-Type` header appropriately.
+
+For development purposes (**only!**), it also sets the `Cache-Control` header
+so your browser doesn't cache the files.  This is useful while developing, to
+ensure your browser displays the newest wasm when you recompile.
+
+In a production environment you **probably wouldn't** want to set the
+`Cache-Control` header like this.  Caching is generally beneficial for end
+users.
+
+Further information on the `Cache-Control` header can be found here:
+
+* https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control

src/examples/wasm/callback/index.html

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+	<meta charset="utf-8" />
+	<title>Go WebAssembly</title>
+	<meta name="viewport" content="width=device-width, initial-scale=1" />
+	<script src="wasm_exec.js" defer></script>
+	<script src="wasm.js" defer></script>
+</head>
+
+<body>
+	<h1>WebAssembly</h1>
+	<p>Add two numbers, using WebAssembly:</p>
+	<input type="number" id="a" value="0" /> + <input type="number" id="b" value="0" /> = <input type="number" id="result" readonly />
+</body>
+
+</html>

src/examples/wasm/callback/wasm.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"strconv"
+	"syscall/js"
+)
+
+var a, b int
+
+func main() {
+	document := js.Global().Get("document")
+	document.Call("getElementById", "a").Set("oninput", updater(&a))
+	document.Call("getElementById", "b").Set("oninput", updater(&b))
+	update()
+}
+
+func updater(n *int) js.Func {
+	return js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+		*n, _ = strconv.Atoi(this.Get("value").String())
+		update()
+		return nil
+	})
+}
+
+func update() {
+	js.Global().Get("document").Call("getElementById", "result").Set("value", a+b)
+}

src/examples/wasm/callback/wasm.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const WASM_URL = 'wasm.wasm';
+
+var wasm;
+
+function init() {
+  const go = new Go();
+  if ('instantiateStreaming' in WebAssembly) {
+    WebAssembly.instantiateStreaming(fetch(WASM_URL), go.importObject).then(function (obj) {
+      wasm = obj.instance;
+      go.run(wasm);
+    })
+  } else {
+    fetch(WASM_URL).then(resp =>
+      resp.arrayBuffer()
+    ).then(bytes =>
+      WebAssembly.instantiate(bytes, go.importObject).then(function (obj) {
+        wasm = obj.instance;
+        go.run(wasm);
+      })
+    )
+  }
+}
+
+init();

src/examples/wasm/main/main.go

@@ -1,9 +1,5 @@
 package main
 
-import (
-	"fmt"
-)
-
 func main() {
-	fmt.Println("Hello world!")
+	println("Hello world!")
 }

src/examples/wasm/server.go

@@ -12,10 +12,10 @@ func main() {
 	fs := http.FileServer(http.Dir(dir))
 	log.Print("Serving " + dir + " on http://localhost:8080")
 	http.ListenAndServe(":8080", http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+		resp.Header().Add("Cache-Control", "no-cache")
 		if strings.HasSuffix(req.URL.Path, ".wasm") {
 			resp.Header().Set("content-type", "application/wasm")
 		}
-
 		fs.ServeHTTP(resp, req)
 	}))
 }

src/machine/board_arduino.go

@@ -5,20 +5,20 @@ package machine
 const CPU_FREQUENCY = 16000000
 
 // LED on the Arduino
-const LED = 13
+const LED Pin = 13
 
 // ADC on the Arduino
 const (
-	ADC0 = 0
-	ADC1 = 1
-	ADC2 = 2
-	ADC3 = 3
-	ADC4 = 4 // Used by TWI for SDA
-	ADC5 = 5 // 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 = 1
-	UART_RX_PIN = 0
+	UART_TX_PIN Pin = 1
+	UART_RX_PIN Pin = 0
 )

src/machine/board_circuitplay_express.go

@@ -17,7 +17,7 @@ const (
 	D8  = PB23
 	D9  = PA06
 	D10 = PA07
-	D11 = 0xff // does not seem to exist
+	D11 = NoPin // does not seem to exist
 	D12 = PA02
 	D13 = PA17 // PWM available
 )
@@ -80,12 +80,12 @@ var (
 	I2C0 = I2C{Bus: sam.SERCOM5_I2CM,
 		SDA:     SDA_PIN,
 		SCL:     SCL_PIN,
-		PinMode: GPIO_SERCOM}
+		PinMode: PinSERCOM}
 	// internal device
 	I2C1 = I2C{Bus: sam.SERCOM1_I2CM,
 		SDA:     SDA1_PIN,
 		SCL:     SCL1_PIN,
-		PinMode: GPIO_SERCOM_ALT}
+		PinMode: PinSERCOMAlt}
 )
 
 // SPI pins (internal flash)
@@ -99,3 +99,15 @@ const (
 var (
 	SPI0 = SPI{Bus: sam.SERCOM3_SPI}
 )
+
+// I2S pins
+const (
+	I2S_SCK_PIN = PA10
+	I2S_SD_PIN  = PA08
+	I2S_WS_PIN  = NoPin // no WS, instead uses SCK to sync
+)
+
+// I2S on the Circuit Playground Express.
+var (
+	I2S0 = I2S{Bus: sam.I2S}
+)

src/machine/board_digispark.go

@@ -3,5 +3,5 @@
 package machine
 
 const (
-	LED = 1
+	LED Pin = 1
 )

src/machine/board_feather-m0.go

@@ -0,0 +1,82 @@
+// +build sam,atsamd21,feather_m0
+
+package machine
+
+import "device/sam"
+
+// GPIO Pins
+const (
+	D0  = PA11  // UART0 RX
+	D1  = PA10  // UART0 TX
+	D2  = NoPin // does not seem to exist
+	D3  = PA09
+	D4  = PA08
+	D5  = PA15  // PWM available
+	D6  = PA20  // PWM available
+	D7  = NoPin // does not seem to exist
+	D8  = PA06
+	D9  = PA07 // PWM available
+	D10 = PA18 // can be used for PWM or UART1 TX
+	D11 = PA16 // can be used for PWM or UART1 RX
+	D12 = PA19 // PWM available
+	D13 = PA17 // PWM available
+)
+
+// Analog pins
+const (
+	A0 = PA02 // ADC/AIN[0]
+	A1 = PB08 // ADC/AIN[2]
+	A2 = PB09 // ADC/AIN[3]
+	A3 = PA04 // ADC/AIN[4]
+	A4 = PA05 // ADC/AIN[5]
+	A5 = PB02 // ADC/AIN[10]
+)
+
+const (
+	LED = D13
+)
+
+// UART0 aka USBCDC pins
+const (
+	USBCDC_DM_PIN = PA24
+	USBCDC_DP_PIN = PA25
+)
+
+// UART1 pins
+const (
+	UART_TX_PIN = D10
+	UART_RX_PIN = D11
+)
+
+// I2C pins
+const (
+	SDA_PIN = PA22 // SDA: SERCOM3/PAD[0]
+	SCL_PIN = PA23 // SCL: SERCOM3/PAD[1]
+)
+
+// I2C on the Feather M0.
+var (
+	I2C0 = I2C{Bus: sam.SERCOM3_I2CM,
+		SDA:     SDA_PIN,
+		SCL:     SCL_PIN,
+		PinMode: PinSERCOM}
+)
+
+// SPI pins
+const (
+	SPI0_SCK_PIN  = PB11 // SCK: SERCOM4/PAD[3]
+	SPI0_MOSI_PIN = PB10 // MOSI: SERCOM4/PAD[2]
+	SPI0_MISO_PIN = PA12 // MISO: SERCOM4/PAD[0]
+)
+
+// SPI on the Feather M0.
+var (
+	SPI0 = SPI{Bus: sam.SERCOM4_SPI}
+)
+
+// I2S pins
+const (
+	I2S_SCK_PIN = PA10
+	I2S_SD_PIN  = PA08
+	I2S_WS_PIN  = NoPin // TODO: figure out what this is on Feather M0.
+)

src/machine/board_itsybitsy-m0.go

@@ -59,7 +59,7 @@ var (
 	I2C0 = I2C{Bus: sam.SERCOM3_I2CM,
 		SDA:     SDA_PIN,
 		SCL:     SCL_PIN,
-		PinMode: GPIO_SERCOM}
+		PinMode: PinSERCOM}
 )
 
 // SPI pins
@@ -73,3 +73,15 @@ const (
 var (
 	SPI0 = SPI{Bus: sam.SERCOM4_SPI}
 )
+
+// I2S pins
+const (
+	I2S_SCK_PIN = PA10
+	I2S_SD_PIN  = PA08
+	I2S_WS_PIN  = NoPin // TODO: figure out what this is on ItsyBitsy M0.
+)
+
+// I2S on the ItsyBitsy M0.
+var (
+	I2S0 = I2S{Bus: sam.I2S}
+)

src/machine/board_microbit.go

@@ -2,142 +2,75 @@
 
 package machine
 
-import (
-	"device/nrf"
-	"errors"
-)
-
 // The micro:bit does not have a 32kHz crystal on board.
 const HasLowFrequencyCrystal = false
 
 // Buttons on the micro:bit (A and B)
 const (
-	BUTTON  = BUTTONA
-	BUTTONA = 17
-	BUTTONB = 26
+	BUTTON  Pin = BUTTONA
+	BUTTONA Pin = 17
+	BUTTONB Pin = 26
 )
 
 // UART pins
 const (
-	UART_TX_PIN = 24
-	UART_RX_PIN = 25
+	UART_TX_PIN Pin = 24
+	UART_RX_PIN Pin = 25
 )
 
 // ADC pins
 const (
-	ADC0 = 3 // P0 on the board
-	ADC1 = 2 // P1 on the board
-	ADC2 = 1 // P2 on the board
+	ADC0 Pin = 3 // P0 on the board
+	ADC1 Pin = 2 // P1 on the board
+	ADC2 Pin = 1 // P2 on the board
 )
 
 // I2C pins
 const (
-	SDA_PIN = 30 // P20 on the board
-	SCL_PIN = 0  // P19 on the board
+	SDA_PIN Pin = 30 // P20 on the board
+	SCL_PIN Pin = 0  // P19 on the board
 )
 
 // SPI pins
 const (
-	SPI0_SCK_PIN  = 23 // P13 on the board
-	SPI0_MOSI_PIN = 21 // P15 on the board
-	SPI0_MISO_PIN = 22 // P14 on the board
+	SPI0_SCK_PIN  Pin = 23 // P13 on the board
+	SPI0_MOSI_PIN Pin = 21 // P15 on the board
+	SPI0_MISO_PIN Pin = 22 // P14 on the board
 )
 
 // GPIO/Analog pins
 const (
-	P0  = 3
-	P1  = 2
-	P2  = 1
-	P3  = 4
-	P4  = 5
-	P5  = 17
-	P6  = 12
-	P7  = 11
-	P8  = 18
-	P9  = 10
-	P10 = 6
-	P11 = 26
-	P12 = 20
-	P13 = 23
-	P14 = 22
-	P15 = 21
-	P16 = 16
+	P0  Pin = 3
+	P1  Pin = 2
+	P2  Pin = 1
+	P3  Pin = 4
+	P4  Pin = 5
+	P5  Pin = 17
+	P6  Pin = 12
+	P7  Pin = 11
+	P8  Pin = 18
+	P9  Pin = 10
+	P10 Pin = 6
+	P11 Pin = 26
+	P12 Pin = 20
+	P13 Pin = 23
+	P14 Pin = 22
+	P15 Pin = 21
+	P16 Pin = 16
 )
 
 // LED matrix pins
 const (
-	LED_COL_1 = 4
-	LED_COL_2 = 5
-	LED_COL_3 = 6
-	LED_COL_4 = 7
-	LED_COL_5 = 8
-	LED_COL_6 = 9
-	LED_COL_7 = 10
-	LED_COL_8 = 11
-	LED_COL_9 = 12
-	LED_ROW_1 = 13
-	LED_ROW_2 = 14
-	LED_ROW_3 = 15
+	LED_COL_1 Pin = 4
+	LED_COL_2 Pin = 5
+	LED_COL_3 Pin = 6
+	LED_COL_4 Pin = 7
+	LED_COL_5 Pin = 8
+	LED_COL_6 Pin = 9
+	LED_COL_7 Pin = 10
+	LED_COL_8 Pin = 11
+	LED_COL_9 Pin = 12
+	LED_ROW_1 Pin = 13
+	LED_ROW_2 Pin = 14
+	LED_ROW_3 Pin = 15
 )
-
-// matrixSettings has the legs of the LED grid in the form {row, column} for each LED position.
-var matrixSettings = [5][5][2]uint8{
-	{{LED_ROW_1, LED_COL_1}, {LED_ROW_2, LED_COL_4}, {LED_ROW_1, LED_COL_2}, {LED_ROW_2, LED_COL_5}, {LED_ROW_1, LED_COL_3}},
-	{{LED_ROW_3, LED_COL_4}, {LED_ROW_3, LED_COL_5}, {LED_ROW_3, LED_COL_6}, {LED_ROW_3, LED_COL_7}, {LED_ROW_3, LED_COL_8}},
-	{{LED_ROW_2, LED_COL_2}, {LED_ROW_1, LED_COL_9}, {LED_ROW_2, LED_COL_3}, {LED_ROW_3, LED_COL_9}, {LED_ROW_2, LED_COL_1}},
-	{{LED_ROW_1, LED_COL_8}, {LED_ROW_1, LED_COL_7}, {LED_ROW_1, LED_COL_6}, {LED_ROW_1, LED_COL_5}, {LED_ROW_1, LED_COL_4}},
-	{{LED_ROW_3, LED_COL_3}, {LED_ROW_2, LED_COL_7}, {LED_ROW_3, LED_COL_1}, {LED_ROW_2, LED_COL_6}, {LED_ROW_3, LED_COL_2}}}
-
-// InitLEDMatrix initializes the LED matrix, by setting all of the row/col pins to output
-// then calling ClearLEDMatrix.
-func InitLEDMatrix() {
-	set := 0
-	for i := LED_COL_1; i <= LED_ROW_3; i++ {
-		set |= 1 << uint8(i)
-	}
-	nrf.GPIO.DIRSET = nrf.RegValue(set)
-	ClearLEDMatrix()
-}
-
-// ClearLEDMatrix clears the entire LED matrix.
-func ClearLEDMatrix() {
-	set := 0
-	for i := LED_COL_1; i <= LED_COL_9; i++ {
-		set |= 1 << uint8(i)
-	}
-	nrf.GPIO.OUTSET = nrf.RegValue(set)
-	nrf.GPIO.OUTCLR = (1 << LED_ROW_1) | (1 << LED_ROW_2) | (1 << LED_ROW_3)
-}
-
-// SetLEDMatrix turns on a single LED on the LED matrix.
-// Currently limited to a single LED at a time, it will clear the matrix before setting it.
-func SetLEDMatrix(x, y uint8) error {
-	if x > 4 || y > 4 {
-		return errors.New("Invalid LED matrix row or column")
-	}
-
-	// Clear matrix
-	ClearLEDMatrix()
-
-	nrf.GPIO.OUTSET = (1 << matrixSettings[y][x][0])
-	nrf.GPIO.OUTCLR = (1 << matrixSettings[y][x][1])
-
-	return nil
-}
-
-// SetEntireLEDMatrixOn turns on all of the LEDs on the LED matrix.
-func SetEntireLEDMatrixOn() error {
-	set := 0
-	for i := LED_ROW_1; i <= LED_ROW_3; i++ {
-		set |= 1 << uint8(i)
-	}
-	nrf.GPIO.OUTSET = nrf.RegValue(set)
-
-	set = 0
-	for i := LED_COL_1; i <= LED_COL_9; i++ {
-		set |= 1 << uint8(i)
-	}
-	nrf.GPIO.OUTCLR = nrf.RegValue(set)
-
-	return nil
-}

src/machine/board_nrf52840-mdk.go

@@ -6,27 +6,27 @@ const HasLowFrequencyCrystal = true
 
 // LEDs on the nrf52840-mdk (nRF52840 dev board)
 const (
-	LED       = LED_GREEN
-	LED_GREEN = 22
-	LED_RED   = 23
-	LED_BLUE  = 24
+	LED       Pin = LED_GREEN
+	LED_GREEN Pin = 22
+	LED_RED   Pin = 23
+	LED_BLUE  Pin = 24
 )
 
 // UART pins
 const (
-	UART_TX_PIN = 20
-	UART_RX_PIN = 19
+	UART_TX_PIN Pin = 20
+	UART_RX_PIN Pin = 19
 )
 
 // I2C pins (unused)
 const (
-	SDA_PIN = 0xff
-	SCL_PIN = 0xff
+	SDA_PIN = NoPin
+	SCL_PIN = NoPin
 )
 
 // SPI pins (unused)
 const (
-	SPI0_SCK_PIN  = 0
-	SPI0_MOSI_PIN = 0
-	SPI0_MISO_PIN = 0
+	SPI0_SCK_PIN  = NoPin
+	SPI0_MOSI_PIN = NoPin
+	SPI0_MISO_PIN = NoPin
 )

src/machine/board_pca10031.go

@@ -10,30 +10,30 @@ const HasLowFrequencyCrystal = true
 
 // LED on the pca10031
 const (
-	LED       = LED_RED
-	LED1      = LED_RED
-	LED2      = LED_GREEN
-	LED3      = LED_BLUE
-	LED_RED   = 21
-	LED_GREEN = 22
-	LED_BLUE  = 23
+	LED       Pin = LED_RED
+	LED1      Pin = LED_RED
+	LED2      Pin = LED_GREEN
+	LED3      Pin = LED_BLUE
+	LED_RED   Pin = 21
+	LED_GREEN Pin = 22
+	LED_BLUE  Pin = 23
 )
 
 // UART pins
 const (
-	UART_TX_PIN = 9
-	UART_RX_PIN = 11
+	UART_TX_PIN Pin = 9
+	UART_RX_PIN Pin = 11
 )
 
 // I2C pins (disabled)
 const (
-	SDA_PIN = 0xff
-	SCL_PIN = 0xff
+	SDA_PIN = NoPin
+	SCL_PIN = NoPin
 )
 
 // SPI pins (unused)
 const (
-	SPI0_SCK_PIN  = 0
-	SPI0_MOSI_PIN = 0
-	SPI0_MISO_PIN = 0
+	SPI0_SCK_PIN  = NoPin
+	SPI0_MOSI_PIN = NoPin
+	SPI0_MISO_PIN = NoPin
 )

src/machine/board_pca10040.go

@@ -7,47 +7,47 @@ const HasLowFrequencyCrystal = true
 
 // LEDs on the PCA10040 (nRF52832 dev board)
 const (
-	LED  = LED1
-	LED1 = 17
-	LED2 = 18
-	LED3 = 19
-	LED4 = 20
+	LED  Pin = LED1
+	LED1 Pin = 17
+	LED2 Pin = 18
+	LED3 Pin = 19
+	LED4 Pin = 20
 )
 
 // Buttons on the PCA10040 (nRF52832 dev board)
 const (
-	BUTTON  = BUTTON1
-	BUTTON1 = 13
-	BUTTON2 = 14
-	BUTTON3 = 15
-	BUTTON4 = 16
+	BUTTON  Pin = BUTTON1
+	BUTTON1 Pin = 13
+	BUTTON2 Pin = 14
+	BUTTON3 Pin = 15
+	BUTTON4 Pin = 16
 )
 
 // UART pins for NRF52840-DK
 const (
-	UART_TX_PIN = 6
-	UART_RX_PIN = 8
+	UART_TX_PIN Pin = 6
+	UART_RX_PIN Pin = 8
 )
 
 // ADC pins
 const (
-	ADC0 = 3
-	ADC1 = 4
-	ADC2 = 28
-	ADC3 = 29
-	ADC4 = 30
-	ADC5 = 31
+	ADC0 Pin = 3
+	ADC1 Pin = 4
+	ADC2 Pin = 28
+	ADC3 Pin = 29
+	ADC4 Pin = 30
+	ADC5 Pin = 31
 )
 
 // I2C pins
 const (
-	SDA_PIN = 26
-	SCL_PIN = 27
+	SDA_PIN Pin = 26
+	SCL_PIN Pin = 27
 )
 
 // SPI pins
 const (
-	SPI0_SCK_PIN  = 25
-	SPI0_MOSI_PIN = 23
-	SPI0_MISO_PIN = 24
+	SPI0_SCK_PIN  Pin = 25
+	SPI0_MOSI_PIN Pin = 23
+	SPI0_MISO_PIN Pin = 24
 )

src/machine/board_pca10056.go

@@ -6,47 +6,47 @@ const HasLowFrequencyCrystal = true
 
 // LEDs on the pca10056
 const (
-	LED  = LED1
-	LED1 = 13
-	LED2 = 14
-	LED3 = 15
-	LED4 = 16
+	LED  Pin = LED1
+	LED1 Pin = 13
+	LED2 Pin = 14
+	LED3 Pin = 15
+	LED4 Pin = 16
 )
 
 // Buttons on the pca10056
 const (
-	BUTTON  = BUTTON1
-	BUTTON1 = 11
-	BUTTON2 = 12
-	BUTTON3 = 24
-	BUTTON4 = 25
+	BUTTON  Pin = BUTTON1
+	BUTTON1 Pin = 11
+	BUTTON2 Pin = 12
+	BUTTON3 Pin = 24
+	BUTTON4 Pin = 25
 )
 
 // UART pins
 const (
-	UART_TX_PIN = 6
-	UART_RX_PIN = 8
+	UART_TX_PIN Pin = 6
+	UART_RX_PIN Pin = 8
 )
 
 // ADC pins
 const (
-	ADC0 = 3
-	ADC1 = 4
-	ADC2 = 28
-	ADC3 = 29
-	ADC4 = 30
-	ADC5 = 31
+	ADC0 Pin = 3
+	ADC1 Pin = 4
+	ADC2 Pin = 28
+	ADC3 Pin = 29
+	ADC4 Pin = 30
+	ADC5 Pin = 31
 )
 
 // I2C pins
 const (
-	SDA_PIN = 26 // P0.26
-	SCL_PIN = 27 // P0.27
+	SDA_PIN Pin = 26 // P0.26
+	SCL_PIN Pin = 27 // P0.27
 )
 
 // SPI pins
 const (
-	SPI0_SCK_PIN  = 47 // P1.15
-	SPI0_MOSI_PIN = 45 // P1.13
-	SPI0_MISO_PIN = 46 // P1.14
+	SPI0_SCK_PIN  Pin = 47 // P1.15
+	SPI0_MOSI_PIN Pin = 45 // P1.13
+	SPI0_MISO_PIN Pin = 46 // P1.14
 )

src/machine/board_reelboard.go

@@ -6,37 +6,37 @@ const HasLowFrequencyCrystal = true
 
 // LEDs on the reel board
 const (
-	LED        = LED1
-	LED1       = LED_YELLOW
-	LED2       = LED_RED
-	LED3       = LED_GREEN
-	LED4       = LED_BLUE
-	LED_RED    = 11
-	LED_GREEN  = 12
-	LED_BLUE   = 41
-	LED_YELLOW = 13
+	LED        Pin = LED1
+	LED1       Pin = LED_YELLOW
+	LED2       Pin = LED_RED
+	LED3       Pin = LED_GREEN
+	LED4       Pin = LED_BLUE
+	LED_RED    Pin = 11
+	LED_GREEN  Pin = 12
+	LED_BLUE   Pin = 41
+	LED_YELLOW Pin = 13
 )
 
 // User "a" button on the reel board
 const (
-	BUTTON = 7
+	BUTTON Pin = 7
 )
 
 // UART pins
 const (
-	UART_TX_PIN = 6
-	UART_RX_PIN = 8
+	UART_TX_PIN Pin = 6
+	UART_RX_PIN Pin = 8
 )
 
 // I2C pins
 const (
-	SDA_PIN = 26
-	SCL_PIN = 27
+	SDA_PIN Pin = 26
+	SCL_PIN Pin = 27
 )
 
 // SPI pins
 const (
-	SPI0_SCK_PIN  = 47
-	SPI0_MOSI_PIN = 45
-	SPI0_MISO_PIN = 46
+	SPI0_SCK_PIN  Pin = 47
+	SPI0_MOSI_PIN Pin = 45
+	SPI0_MISO_PIN Pin = 46
 )

src/machine/board_trinket.go

@@ -0,0 +1,73 @@
+// +build sam,atsamd21,trinket_m0
+
+package machine
+
+import "device/sam"
+
+// GPIO Pins
+const (
+	D0  = PA08 // PWM available
+	D1  = PA02
+	D2  = PA09 // PWM available
+	D3  = PA07 // PWM available / UART0 RX
+	D4  = PA06 // PWM available / UART0 TX
+	D13 = PA10 // LED
+)
+
+// Analog pins
+const (
+	A0 = D1
+	A1 = D2
+	A2 = D0
+	A3 = D3
+	A4 = D4
+)
+
+const (
+	LED = D13
+)
+
+// UART0 aka USBCDC pins
+const (
+	USBCDC_DM_PIN = PA24
+	USBCDC_DP_PIN = PA25
+)
+
+// UART1 pins
+const (
+	UART_TX_PIN = D4
+	UART_RX_PIN = D3
+)
+
+// SPI pins
+const (
+	SPI0_SCK_PIN  = D3
+	SPI0_MOSI_PIN = D4
+	SPI0_MISO_PIN = D2
+)
+
+// SPI on the Trinket M0.
+var (
+	SPI0 = SPI{Bus: sam.SERCOM0_SPI}
+)
+
+// I2C pins
+const (
+	SDA_PIN = D0 // SDA
+	SCL_PIN = D2 // SCL
+)
+
+// I2C on the Trinket M0.
+var (
+	I2C0 = I2C{Bus: sam.SERCOM2_I2CM,
+		SDA:     SDA_PIN,
+		SCL:     SCL_PIN,
+		PinMode: PinSERCOMAlt}
+)
+
+// I2S pins
+const (
+	I2S_SCK_PIN = PA10
+	I2S_SD_PIN  = PA08
+	I2S_WS_PIN  = NoPin // TODO: figure out what this is on Trinket M0.
+)

src/machine/i2s.go

@@ -0,0 +1,54 @@
+// +build sam
+
+// This is the definition for I2S bus functions.
+// Actual implementations if available for any given hardware
+// are to be found in its the board definition.
+//
+// For more info about I2S, see: https://en.wikipedia.org/wiki/I%C2%B2S
+//
+
+package machine
+
+type I2SMode uint8
+type I2SStandard uint8
+type I2SClockSource uint8
+type I2SDataFormat uint8
+
+const (
+	I2SModeMaster I2SMode = iota
+	I2SModeSlave
+	I2SModePDM
+)
+
+const (
+	I2StandardPhilips I2SStandard = iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+
+const (
+	I2SClockSourceInternal I2SClockSource = iota
+	I2SClockSourceExternal
+)
+
+const (
+	I2SDataFormatDefault I2SDataFormat = 0
+	I2SDataFormat8bit                  = 8
+	I2SDataFormat16bit                 = 16
+	I2SDataFormat24bit                 = 24
+	I2SDataFormat32bit                 = 32
+)
+
+// All fields are optional and may not be required or used on a particular platform.
+type I2SConfig struct {
+	SCK               Pin
+	WS                Pin
+	SD                Pin
+	Mode              I2SMode
+	Standard          I2SStandard
+	ClockSource       I2SClockSource
+	DataFormat        I2SDataFormat
+	AudioFrequency    uint32
+	MasterClockOutput bool
+	Stereo            bool
+}

src/machine/machine.go

@@ -1,25 +1,36 @@
 package machine
 
-type GPIOConfig struct {
-	Mode GPIOMode
+type PinConfig struct {
+	Mode PinMode
 }
 
-type GPIO struct {
-	Pin uint8
-}
+// Pin is a single pin on a chip, which may be connected to other hardware
+// devices. It can either be used directly as GPIO pin or it can be used in
+// other peripherals like ADC, I2C, etc.
+type Pin int8
 
-func (p GPIO) High() {
+// NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+// of the pins in a peripheral unconfigured (if supported by the hardware).
+const NoPin = Pin(-1)
+
+// High sets this GPIO pin to high, assuming it has been configured as an output
+// pin. It is hardware dependent (and often undefined) what happens if you set a
+// pin to high that is not configured as an output pin.
+func (p Pin) High() {
 	p.Set(true)
 }
 
-func (p GPIO) Low() {
+// Low sets this GPIO pin to low, assuming it has been configured as an output
+// pin. It is hardware dependent (and often undefined) what happens if you set a
+// pin to low that is not configured as an output pin.
+func (p Pin) Low() {
 	p.Set(false)
 }
 
 type PWM struct {
-	Pin uint8
+	Pin Pin
 }
 
 type ADC struct {
-	Pin uint8
+	Pin Pin
 }

src/machine/machine_atmega.go

@@ -7,102 +7,102 @@ import (
 )
 
 // Configure sets the pin to input or output.
-func (p GPIO) Configure(config GPIOConfig) {
-	if config.Mode == GPIO_OUTPUT { // set output bit
-		if p.Pin < 8 {
-			*avr.DDRD |= 1 << p.Pin
+func (p Pin) Configure(config PinConfig) {
+	if config.Mode == PinOutput { // set output bit
+		if p < 8 {
+			avr.DDRD.SetBits(1 << uint8(p))
 		} else {
-			*avr.DDRB |= 1 << (p.Pin - 8)
+			avr.DDRB.SetBits(1 << uint8(p-8))
 		}
 	} else { // configure input: clear output bit
-		if p.Pin < 8 {
-			*avr.DDRD &^= 1 << p.Pin
+		if p < 8 {
+			avr.DDRD.ClearBits(1 << uint8(p))
 		} else {
-			*avr.DDRB &^= 1 << (p.Pin - 8)
+			avr.DDRB.ClearBits(1 << uint8(p-8))
 		}
 	}
 }
 
 // Get returns the current value of a GPIO pin.
-func (p GPIO) Get() bool {
-	if p.Pin < 8 {
-		val := *avr.PIND & (1 << p.Pin)
+func (p Pin) Get() bool {
+	if p < 8 {
+		val := avr.PIND.Get() & (1 << uint8(p))
 		return (val > 0)
 	} else {
-		val := *avr.PINB & (1 << (p.Pin - 8))
+		val := avr.PINB.Get() & (1 << uint8(p-8))
 		return (val > 0)
 	}
 }
 
-func (p GPIO) getPortMask() (*avr.RegValue, uint8) {
-	if p.Pin < 8 {
-		return avr.PORTD, 1 << p.Pin
+func (p Pin) getPortMask() (*avr.Register8, uint8) {
+	if p < 8 {
+		return avr.PORTD, 1 << uint8(p)
 	} else {
-		return avr.PORTB, 1 << (p.Pin - 8)
+		return avr.PORTB, 1 << uint8(p-8)
 	}
 }
 
 // InitPWM initializes the registers needed for PWM.
 func InitPWM() {
 	// use waveform generation
-	*avr.TCCR0A |= avr.TCCR0A_WGM00
+	avr.TCCR0A.SetBits(avr.TCCR0A_WGM00)
 
 	// set timer 0 prescale factor to 64
-	*avr.TCCR0B |= avr.TCCR0B_CS01 | avr.TCCR0B_CS00
+	avr.TCCR0B.SetBits(avr.TCCR0B_CS01 | avr.TCCR0B_CS00)
 
 	// set timer 1 prescale factor to 64
-	*avr.TCCR1B |= avr.TCCR1B_CS11
+	avr.TCCR1B.SetBits(avr.TCCR1B_CS11)
 
 	// put timer 1 in 8-bit phase correct pwm mode
-	*avr.TCCR1A |= avr.TCCR1A_WGM10
+	avr.TCCR1A.SetBits(avr.TCCR1A_WGM10)
 
 	// set timer 2 prescale factor to 64
-	*avr.TCCR2B |= avr.TCCR2B_CS22
+	avr.TCCR2B.SetBits(avr.TCCR2B_CS22)
 
 	// configure timer 2 for phase correct pwm (8-bit)
-	*avr.TCCR2A |= avr.TCCR2A_WGM20
+	avr.TCCR2A.SetBits(avr.TCCR2A_WGM20)
 }
 
 // Configure configures a PWM pin for output.
 func (pwm PWM) Configure() {
 	if pwm.Pin < 8 {
-		*avr.DDRD |= 1 << pwm.Pin
+		avr.DDRD.SetBits(1 << uint8(pwm.Pin))
 	} else {
-		*avr.DDRB |= 1 << (pwm.Pin - 8)
+		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 := value >> 8
+	value8 := uint8(value >> 8)
 	switch pwm.Pin {
 	case 3:
 		// connect pwm to pin on timer 2, channel B
-		*avr.TCCR2A |= avr.TCCR2A_COM2B1
-		*avr.OCR2B = avr.RegValue(value8) // set pwm duty
+		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 |= avr.TCCR0A_COM0B1
-		*avr.OCR0B = avr.RegValue(value8) // set pwm duty
+		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 |= avr.TCCR0A_COM0A1
-		*avr.OCR0A = avr.RegValue(value8) // set pwm duty
+		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 |= avr.TCCR1A_COM1A1
+		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 = avr.RegValue(value8) // set pwm duty
+		avr.OCR1AL.Set(value8) // set pwm duty
 	case 10:
 		// connect pwm to pin on timer 1, channel B
-		*avr.TCCR1A |= avr.TCCR1A_COM1B1
+		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 = avr.RegValue(value8) // set pwm duty
+		avr.OCR1BL.Set(value8) // set pwm duty
 	case 11:
 		// connect pwm to pin on timer 2, channel A
-		*avr.TCCR2A |= avr.TCCR2A_COM2A1
-		*avr.OCR2A = avr.RegValue(value8) // set pwm duty
+		avr.TCCR2A.SetBits(avr.TCCR2A_COM2A1)
+		avr.OCR2A.Set(value8) // set pwm duty
 	default:
 		panic("Invalid PWM pin")
 	}
@@ -121,19 +121,19 @@ func (i2c I2C) Configure(config I2CConfig) {
 	}
 
 	// Activate internal pullups for twi.
-	*avr.PORTC |= (avr.DIDR0_ADC4D | avr.DIDR0_ADC5D)
+	avr.PORTC.SetBits((avr.DIDR0_ADC4D | avr.DIDR0_ADC5D))
 
 	// Initialize twi prescaler and bit rate.
-	*avr.TWSR |= (avr.TWSR_TWPS0 | avr.TWSR_TWPS1)
+	avr.TWSR.SetBits((avr.TWSR_TWPS0 | avr.TWSR_TWPS1))
 
 	// twi bit rate formula from atmega128 manual pg. 204:
 	// SCL Frequency = CPU Clock Frequency / (16 + (2 * TWBR))
 	// NOTE: TWBR should be 10 or higher for master mode.
 	// It is 72 for a 16mhz board with 100kHz TWI
-	*avr.TWBR = avr.RegValue(((CPU_FREQUENCY / config.Frequency) - 16) / 2)
+	avr.TWBR.Set(uint8(((CPU_FREQUENCY / config.Frequency) - 16) / 2))
 
 	// Enable twi module.
-	*avr.TWCR = avr.TWCR_TWEN
+	avr.TWCR.Set(avr.TWCR_TWEN)
 }
 
 // Tx does a single I2C transaction at the specified address.
@@ -162,10 +162,10 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 // start starts an I2C communication session.
 func (i2c I2C) start(address uint8, write bool) {
 	// Clear TWI interrupt flag, put start condition on SDA, and enable TWI.
-	*avr.TWCR = (avr.TWCR_TWINT | avr.TWCR_TWSTA | avr.TWCR_TWEN)
+	avr.TWCR.Set((avr.TWCR_TWINT | avr.TWCR_TWSTA | avr.TWCR_TWEN))
 
 	// Wait till start condition is transmitted.
-	for (*avr.TWCR & avr.TWCR_TWINT) == 0 {
+	for !avr.TWCR.HasBits(avr.TWCR_TWINT) {
 	}
 
 	// Write 7-bit shifted peripheral address.
@@ -179,36 +179,36 @@ func (i2c I2C) start(address uint8, write bool) {
 // stop ends an I2C communication session.
 func (i2c I2C) stop() {
 	// Send stop condition.
-	*avr.TWCR = (avr.TWCR_TWEN | avr.TWCR_TWINT | avr.TWCR_TWSTO)
+	avr.TWCR.Set(avr.TWCR_TWEN | avr.TWCR_TWINT | avr.TWCR_TWSTO)
 
 	// Wait for stop condition to be executed on bus.
-	for (*avr.TWCR & avr.TWCR_TWSTO) == 0 {
+	for !avr.TWCR.HasBits(avr.TWCR_TWSTO) {
 	}
 }
 
 // writeByte writes a single byte to the I2C bus.
 func (i2c I2C) writeByte(data byte) {
 	// Write data to register.
-	*avr.TWDR = avr.RegValue(data)
+	avr.TWDR.Set(data)
 
 	// Clear TWI interrupt flag and enable TWI.
-	*avr.TWCR = (avr.TWCR_TWEN | avr.TWCR_TWINT)
+	avr.TWCR.Set(avr.TWCR_TWEN | avr.TWCR_TWINT)
 
 	// Wait till data is transmitted.
-	for (*avr.TWCR & avr.TWCR_TWINT) == 0 {
+	for !avr.TWCR.HasBits(avr.TWCR_TWINT) {
 	}
 }
 
 // readByte reads a single byte from the I2C bus.
 func (i2c I2C) readByte() byte {
 	// Clear TWI interrupt flag and enable TWI.
-	*avr.TWCR = (avr.TWCR_TWEN | avr.TWCR_TWINT | avr.TWCR_TWEA)
+	avr.TWCR.Set(avr.TWCR_TWEN | avr.TWCR_TWINT | avr.TWCR_TWEA)
 
 	// Wait till read request is transmitted.
-	for (*avr.TWCR & avr.TWCR_TWINT) == 0 {
+	for !avr.TWCR.HasBits(avr.TWCR_TWINT) {
 	}
 
-	return byte(*avr.TWDR)
+	return byte(avr.TWDR.Get())
 }
 
 // UART on the AVR.
@@ -226,32 +226,32 @@ func (uart UART) Configure(config UARTConfig) {
 	// https://www.microchip.com/webdoc/AVRLibcReferenceManual/FAQ_1faq_wrong_baud_rate.html
 	// ((F_CPU + UART_BAUD_RATE * 8L) / (UART_BAUD_RATE * 16L) - 1)
 	ps := ((CPU_FREQUENCY+config.BaudRate*8)/(config.BaudRate*16) - 1)
-	*avr.UBRR0H = avr.RegValue(ps >> 8)
-	*avr.UBRR0L = avr.RegValue(ps & 0xff)
+	avr.UBRR0H.Set(uint8(ps >> 8))
+	avr.UBRR0L.Set(uint8(ps & 0xff))
 
 	// enable RX, TX and RX interrupt
-	*avr.UCSR0B = avr.UCSR0B_RXEN0 | avr.UCSR0B_TXEN0 | avr.UCSR0B_RXCIE0
+	avr.UCSR0B.Set(avr.UCSR0B_RXEN0 | avr.UCSR0B_TXEN0 | avr.UCSR0B_RXCIE0)
 
 	// 8-bits data
-	*avr.UCSR0C = avr.UCSR0C_UCSZ01 | avr.UCSR0C_UCSZ00
+	avr.UCSR0C.Set(avr.UCSR0C_UCSZ01 | avr.UCSR0C_UCSZ00)
 }
 
 // WriteByte writes a byte of data to the UART.
 func (uart UART) WriteByte(c byte) error {
 	// Wait until UART buffer is not busy.
-	for (*avr.UCSR0A & avr.UCSR0A_UDRE0) == 0 {
+	for !avr.UCSR0A.HasBits(avr.UCSR0A_UDRE0) {
 	}
-	*avr.UDR0 = avr.RegValue(c) // send char
+	avr.UDR0.Set(c) // send char
 	return nil
 }
 
 //go:interrupt USART_RX_vect
 func handleUSART_RX() {
 	// Read register to clear it.
-	data := *avr.UDR0
+	data := avr.UDR0.Get()
 
 	// Ensure no error.
-	if (*avr.UCSR0A & (avr.UCSR0A_FE0 | avr.UCSR0A_DOR0 | avr.UCSR0A_UPE0)) == 0 {
+	if !avr.UCSR0A.HasBits(avr.UCSR0A_FE0 | avr.UCSR0A_DOR0 | avr.UCSR0A_UPE0) {
 		// Put data from UDR register into buffer.
 		UART0.Receive(byte(data))
 	}

src/machine/machine_atsamd21e18.go

@@ -0,0 +1,334 @@
+// +build sam,atsamd21,atsamd21e18
+
+// Peripheral abstraction layer for the atsamd21.
+//
+// Datasheet:
+// http://ww1.microchip.com/downloads/en/DeviceDoc/SAMD21-Family-DataSheet-DS40001882D.pdf
+//
+package machine
+
+import (
+	"device/sam"
+)
+
+// 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) {
+	return &sam.PORT.OUTSET0.Reg, 1 << uint8(p)
+}
+
+// Return the register and mask to disable a given port. This can be used to
+// implement bit-banged drivers.
+func (p Pin) PortMaskClear() (*uint32, uint32) {
+	return &sam.PORT.OUTCLR0.Reg, 1 << uint8(p)
+}
+
+// Set the pin to high or low.
+// Warning: only use this on an output pin!
+func (p Pin) Set(high bool) {
+	if high {
+		sam.PORT.OUTSET0.Set(1 << uint8(p))
+	} else {
+		sam.PORT.OUTCLR0.Set(1 << uint8(p))
+	}
+}
+
+// Get returns the current value of a GPIO pin.
+func (p Pin) Get() bool {
+	return (sam.PORT.IN0.Get()>>uint8(p))&1 > 0
+}
+
+// Configure this pin with the given configuration.
+func (p Pin) Configure(config PinConfig) {
+	switch config.Mode {
+	case PinOutput:
+		sam.PORT.DIRSET0.Set(1 << uint8(p))
+		// output is also set to input enable so pin can read back its own value
+		p.setPinCfg(sam.PORT_PINCFG0_INEN)
+
+	case PinInput:
+		sam.PORT.DIRCLR0.Set(1 << uint8(p))
+		p.setPinCfg(sam.PORT_PINCFG0_INEN)
+
+	case PinInputPulldown:
+		sam.PORT.DIRCLR0.Set(1 << uint8(p))
+		sam.PORT.OUTCLR0.Set(1 << uint8(p))
+		p.setPinCfg(sam.PORT_PINCFG0_INEN | sam.PORT_PINCFG0_PULLEN)
+
+	case PinInputPullup:
+		sam.PORT.DIRCLR0.Set(1 << uint8(p))
+		sam.PORT.OUTSET0.Set(1 << uint8(p))
+		p.setPinCfg(sam.PORT_PINCFG0_INEN | sam.PORT_PINCFG0_PULLEN)
+
+	case PinSERCOM:
+		if uint8(p)&1 > 0 {
+			// odd pin, so save the even pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXE_Msk
+			p.setPMux(val | (uint8(PinSERCOM) << sam.PORT_PMUX0_PMUXO_Pos))
+		} else {
+			// even pin, so save the odd pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
+			p.setPMux(val | (uint8(PinSERCOM) << sam.PORT_PMUX0_PMUXE_Pos))
+		}
+		// enable port config
+		p.setPinCfg(sam.PORT_PINCFG0_PMUXEN | sam.PORT_PINCFG0_DRVSTR | sam.PORT_PINCFG0_INEN)
+
+	case PinSERCOMAlt:
+		if uint8(p)&1 > 0 {
+			// odd pin, so save the even pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXE_Msk
+			p.setPMux(val | (uint8(PinSERCOMAlt) << sam.PORT_PMUX0_PMUXO_Pos))
+		} else {
+			// even pin, so save the odd pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
+			p.setPMux(val | (uint8(PinSERCOMAlt) << sam.PORT_PMUX0_PMUXE_Pos))
+		}
+		// enable port config
+		p.setPinCfg(sam.PORT_PINCFG0_PMUXEN | sam.PORT_PINCFG0_DRVSTR)
+
+	case PinCom:
+		if uint8(p)&1 > 0 {
+			// odd pin, so save the even pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXE_Msk
+			p.setPMux(val | (uint8(PinCom) << sam.PORT_PMUX0_PMUXO_Pos))
+		} else {
+			// even pin, so save the odd pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
+			p.setPMux(val | (uint8(PinCom) << sam.PORT_PMUX0_PMUXE_Pos))
+		}
+		// enable port config
+		p.setPinCfg(sam.PORT_PINCFG0_PMUXEN)
+	case PinAnalog:
+		if uint8(p)&1 > 0 {
+			// odd pin, so save the even pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXE_Msk
+			p.setPMux(val | (uint8(PinAnalog) << sam.PORT_PMUX0_PMUXO_Pos))
+		} else {
+			// even pin, so save the odd pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
+			p.setPMux(val | (uint8(PinAnalog) << sam.PORT_PMUX0_PMUXE_Pos))
+		}
+		// enable port config
+		p.setPinCfg(sam.PORT_PINCFG0_PMUXEN | sam.PORT_PINCFG0_DRVSTR)
+	}
+}
+
+// getPMux returns the value for the correct PMUX register for this pin.
+func (p Pin) getPMux() uint8 {
+	switch p >> 1 {
+	case 0:
+		return sam.PORT.PMUX0_0.Get()
+	case 1:
+		return sam.PORT.PMUX0_1.Get()
+	case 2:
+		return sam.PORT.PMUX0_2.Get()
+	case 3:
+		return sam.PORT.PMUX0_3.Get()
+	case 4:
+		return sam.PORT.PMUX0_4.Get()
+	case 5:
+		return sam.PORT.PMUX0_5.Get()
+	case 6:
+		return sam.PORT.PMUX0_6.Get()
+	case 7:
+		return sam.PORT.PMUX0_7.Get()
+	case 8:
+		return sam.PORT.PMUX0_8.Get()
+	case 9:
+		return sam.PORT.PMUX0_9.Get()
+	case 10:
+		return sam.PORT.PMUX0_10.Get()
+	case 11:
+		return sam.PORT.PMUX0_11.Get()
+	case 12:
+		return sam.PORT.PMUX0_12.Get()
+	case 13:
+		return sam.PORT.PMUX0_13.Get()
+	case 14:
+		return sam.PORT.PMUX0_14.Get()
+	case 15:
+		return sam.PORT.PMUX0_15.Get()
+	default:
+		return 0
+	}
+}
+
+// setPMux sets the value for the correct PMUX register for this pin.
+func (p Pin) setPMux(val uint8) {
+	switch p >> 1 {
+	case 0:
+		sam.PORT.PMUX0_0.Set(val)
+	case 1:
+		sam.PORT.PMUX0_1.Set(val)
+	case 2:
+		sam.PORT.PMUX0_2.Set(val)
+	case 3:
+		sam.PORT.PMUX0_3.Set(val)
+	case 4:
+		sam.PORT.PMUX0_4.Set(val)
+	case 5:
+		sam.PORT.PMUX0_5.Set(val)
+	case 6:
+		sam.PORT.PMUX0_6.Set(val)
+	case 7:
+		sam.PORT.PMUX0_7.Set(val)
+	case 8:
+		sam.PORT.PMUX0_8.Set(val)
+	case 9:
+		sam.PORT.PMUX0_9.Set(val)
+	case 10:
+		sam.PORT.PMUX0_10.Set(val)
+	case 11:
+		sam.PORT.PMUX0_11.Set(val)
+	case 12:
+		sam.PORT.PMUX0_12.Set(val)
+	case 13:
+		sam.PORT.PMUX0_13.Set(val)
+	case 14:
+		sam.PORT.PMUX0_14.Set(val)
+	case 15:
+		sam.PORT.PMUX0_15.Set(val)
+	}
+}
+
+// getPinCfg returns the value for the correct PINCFG register for this pin.
+func (p Pin) getPinCfg() uint8 {
+	switch p {
+	case 0:
+		return sam.PORT.PINCFG0_0.Get()
+	case 1:
+		return sam.PORT.PINCFG0_1.Get()
+	case 2:
+		return sam.PORT.PINCFG0_2.Get()
+	case 3:
+		return sam.PORT.PINCFG0_3.Get()
+	case 4:
+		return sam.PORT.PINCFG0_4.Get()
+	case 5:
+		return sam.PORT.PINCFG0_5.Get()
+	case 6:
+		return sam.PORT.PINCFG0_6.Get()
+	case 7:
+		return sam.PORT.PINCFG0_7.Get()
+	case 8:
+		return sam.PORT.PINCFG0_8.Get()
+	case 9:
+		return sam.PORT.PINCFG0_9.Get()
+	case 10:
+		return sam.PORT.PINCFG0_10.Get()
+	case 11:
+		return sam.PORT.PINCFG0_11.Get()
+	case 12:
+		return sam.PORT.PINCFG0_12.Get()
+	case 13:
+		return sam.PORT.PINCFG0_13.Get()
+	case 14:
+		return sam.PORT.PINCFG0_14.Get()
+	case 15:
+		return sam.PORT.PINCFG0_15.Get()
+	case 16:
+		return sam.PORT.PINCFG0_16.Get()
+	case 17:
+		return sam.PORT.PINCFG0_17.Get()
+	case 18:
+		return sam.PORT.PINCFG0_18.Get()
+	case 19:
+		return sam.PORT.PINCFG0_19.Get()
+	case 20:
+		return sam.PORT.PINCFG0_20.Get()
+	case 21:
+		return sam.PORT.PINCFG0_21.Get()
+	case 22:
+		return sam.PORT.PINCFG0_22.Get()
+	case 23:
+		return sam.PORT.PINCFG0_23.Get()
+	case 24:
+		return sam.PORT.PINCFG0_24.Get()
+	case 25:
+		return sam.PORT.PINCFG0_25.Get()
+	case 26:
+		return sam.PORT.PINCFG0_26.Get()
+	case 27:
+		return sam.PORT.PINCFG0_27.Get()
+	case 28:
+		return sam.PORT.PINCFG0_28.Get()
+	case 29:
+		return sam.PORT.PINCFG0_29.Get()
+	case 30:
+		return sam.PORT.PINCFG0_30.Get()
+	case 31:
+		return sam.PORT.PINCFG0_31.Get()
+	default:
+		return 0
+	}
+}
+
+// setPinCfg sets the value for the correct PINCFG register for this pin.
+func (p Pin) setPinCfg(val uint8) {
+	switch p {
+	case 0:
+		sam.PORT.PINCFG0_0.Set(val)
+	case 1:
+		sam.PORT.PINCFG0_1.Set(val)
+	case 2:
+		sam.PORT.PINCFG0_2.Set(val)
+	case 3:
+		sam.PORT.PINCFG0_3.Set(val)
+	case 4:
+		sam.PORT.PINCFG0_4.Set(val)
+	case 5:
+		sam.PORT.PINCFG0_5.Set(val)
+	case 6:
+		sam.PORT.PINCFG0_6.Set(val)
+	case 7:
+		sam.PORT.PINCFG0_7.Set(val)
+	case 8:
+		sam.PORT.PINCFG0_8.Set(val)
+	case 9:
+		sam.PORT.PINCFG0_9.Set(val)
+	case 10:
+		sam.PORT.PINCFG0_10.Set(val)
+	case 11:
+		sam.PORT.PINCFG0_11.Set(val)
+	case 12:
+		sam.PORT.PINCFG0_12.Set(val)
+	case 13:
+		sam.PORT.PINCFG0_13.Set(val)
+	case 14:
+		sam.PORT.PINCFG0_14.Set(val)
+	case 15:
+		sam.PORT.PINCFG0_15.Set(val)
+	case 16:
+		sam.PORT.PINCFG0_16.Set(val)
+	case 17:
+		sam.PORT.PINCFG0_17.Set(val)
+	case 18:
+		sam.PORT.PINCFG0_18.Set(val)
+	case 19:
+		sam.PORT.PINCFG0_19.Set(val)
+	case 20:
+		sam.PORT.PINCFG0_20.Set(val)
+	case 21:
+		sam.PORT.PINCFG0_21.Set(val)
+	case 22:
+		sam.PORT.PINCFG0_22.Set(val)
+	case 23:
+		sam.PORT.PINCFG0_23.Set(val)
+	case 24:
+		sam.PORT.PINCFG0_24.Set(val)
+	case 25:
+		sam.PORT.PINCFG0_25.Set(val)
+	case 26:
+		sam.PORT.PINCFG0_26.Set(val)
+	case 27:
+		sam.PORT.PINCFG0_27.Set(val)
+	case 28:
+		sam.PORT.PINCFG0_28.Set(val)
+	case 29:
+		sam.PORT.PINCFG0_29.Set(val)
+	case 30:
+		sam.PORT.PINCFG0_30.Set(val)
+	case 31:
+		sam.PORT.PINCFG0_31.Set(val)
+	}
+}

src/machine/machine_atsamd21g18.go

@@ -0,0 +1,569 @@
+// +build sam,atsamd21,atsamd21g18
+
+// Peripheral abstraction layer for the atsamd21.
+//
+// Datasheet:
+// http://ww1.microchip.com/downloads/en/DeviceDoc/SAMD21-Family-DataSheet-DS40001882D.pdf
+//
+package machine
+
+import (
+	"device/sam"
+)
+
+// 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) {
+	if p < 32 {
+		return &sam.PORT.OUTSET0.Reg, 1 << uint8(p)
+	} else {
+		return &sam.PORT.OUTSET1.Reg, 1 << uint8(p-32)
+	}
+}
+
+// Return the register and mask to disable a given port. This can be used to
+// implement bit-banged drivers.
+func (p Pin) PortMaskClear() (*uint32, uint32) {
+	if p < 32 {
+		return &sam.PORT.OUTCLR0.Reg, 1 << uint8(p)
+	} else {
+		return &sam.PORT.OUTCLR1.Reg, 1 << uint8(p-32)
+	}
+}
+
+// Set the pin to high or low.
+// Warning: only use this on an output pin!
+func (p Pin) Set(high bool) {
+	if p < 32 {
+		if high {
+			sam.PORT.OUTSET0.Set(1 << uint8(p))
+		} else {
+			sam.PORT.OUTCLR0.Set(1 << uint8(p))
+		}
+	} else {
+		if high {
+			sam.PORT.OUTSET1.Set(1 << uint8(p-32))
+		} else {
+			sam.PORT.OUTCLR1.Set(1 << uint8(p-32))
+		}
+	}
+}
+
+// Get returns the current value of a GPIO pin.
+func (p Pin) Get() bool {
+	if p < 32 {
+		return (sam.PORT.IN0.Get()>>uint8(p))&1 > 0
+	} else {
+		return (sam.PORT.IN1.Get()>>(uint8(p)-32))&1 > 0
+	}
+}
+
+// Configure this pin with the given configuration.
+func (p Pin) Configure(config PinConfig) {
+	switch config.Mode {
+	case PinOutput:
+		if p < 32 {
+			sam.PORT.DIRSET0.Set(1 << uint8(p))
+			// output is also set to input enable so pin can read back its own value
+			p.setPinCfg(sam.PORT_PINCFG0_INEN)
+		} else {
+			sam.PORT.DIRSET1.Set(1 << uint8(p-32))
+			// output is also set to input enable so pin can read back its own value
+			p.setPinCfg(sam.PORT_PINCFG0_INEN)
+		}
+
+	case PinInput:
+		if p < 32 {
+			sam.PORT.DIRCLR0.Set(1 << uint8(p))
+			p.setPinCfg(sam.PORT_PINCFG0_INEN)
+		} else {
+			sam.PORT.DIRCLR1.Set(1<<uint8(p) - 32)
+			p.setPinCfg(sam.PORT_PINCFG0_INEN)
+		}
+
+	case PinInputPulldown:
+		if p < 32 {
+			sam.PORT.DIRCLR0.Set(1 << uint8(p))
+			sam.PORT.OUTCLR0.Set(1 << uint8(p))
+			p.setPinCfg(sam.PORT_PINCFG0_INEN | sam.PORT_PINCFG0_PULLEN)
+		} else {
+			sam.PORT.DIRCLR1.Set(1<<uint8(p) - 32)
+			sam.PORT.OUTCLR1.Set(1<<uint8(p) - 32)
+			p.setPinCfg(sam.PORT_PINCFG0_INEN | sam.PORT_PINCFG0_PULLEN)
+		}
+
+	case PinInputPullup:
+		if p < 32 {
+			sam.PORT.DIRCLR0.Set(1 << uint8(p))
+			sam.PORT.OUTSET0.Set(1 << uint8(p))
+			p.setPinCfg(sam.PORT_PINCFG0_INEN | sam.PORT_PINCFG0_PULLEN)
+		} else {
+			sam.PORT.DIRCLR1.Set(1<<uint8(p) - 32)
+			sam.PORT.OUTSET1.Set(1<<uint8(p) - 32)
+			p.setPinCfg(sam.PORT_PINCFG0_INEN | sam.PORT_PINCFG0_PULLEN)
+		}
+
+	case PinSERCOM:
+		if p&1 > 0 {
+			// odd pin, so save the even pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXE_Msk
+			p.setPMux(val | (uint8(PinSERCOM) << sam.PORT_PMUX0_PMUXO_Pos))
+		} else {
+			// even pin, so save the odd pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
+			p.setPMux(val | (uint8(PinSERCOM) << sam.PORT_PMUX0_PMUXE_Pos))
+		}
+		// enable port config
+		p.setPinCfg(sam.PORT_PINCFG0_PMUXEN | sam.PORT_PINCFG0_DRVSTR | sam.PORT_PINCFG0_INEN)
+
+	case PinSERCOMAlt:
+		if p&1 > 0 {
+			// odd pin, so save the even pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXE_Msk
+			p.setPMux(val | (uint8(PinSERCOMAlt) << sam.PORT_PMUX0_PMUXO_Pos))
+		} else {
+			// even pin, so save the odd pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
+			p.setPMux(val | (uint8(PinSERCOMAlt) << sam.PORT_PMUX0_PMUXE_Pos))
+		}
+		// enable port config
+		p.setPinCfg(sam.PORT_PINCFG0_PMUXEN | sam.PORT_PINCFG0_DRVSTR)
+
+	case PinCom:
+		if p&1 > 0 {
+			// odd pin, so save the even pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXE_Msk
+			p.setPMux(val | (uint8(PinCom) << sam.PORT_PMUX0_PMUXO_Pos))
+		} else {
+			// even pin, so save the odd pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
+			p.setPMux(val | (uint8(PinCom) << sam.PORT_PMUX0_PMUXE_Pos))
+		}
+		// enable port config
+		p.setPinCfg(sam.PORT_PINCFG0_PMUXEN)
+	case PinAnalog:
+		if p&1 > 0 {
+			// odd pin, so save the even pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXE_Msk
+			p.setPMux(val | (uint8(PinAnalog) << sam.PORT_PMUX0_PMUXO_Pos))
+		} else {
+			// even pin, so save the odd pins
+			val := p.getPMux() & sam.PORT_PMUX0_PMUXO_Msk
+			p.setPMux(val | (uint8(PinAnalog) << sam.PORT_PMUX0_PMUXE_Pos))
+		}
+		// enable port config
+		p.setPinCfg(sam.PORT_PINCFG0_PMUXEN | sam.PORT_PINCFG0_DRVSTR)
+	}
+}
+
+// getPMux returns the value for the correct PMUX register for this pin.
+func (p Pin) getPMux() uint8 {
+	switch uint8(p) >> 1 {
+	case 0:
+		return sam.PORT.PMUX0_0.Get()
+	case 1:
+		return sam.PORT.PMUX0_1.Get()
+	case 2:
+		return sam.PORT.PMUX0_2.Get()
+	case 3:
+		return sam.PORT.PMUX0_3.Get()
+	case 4:
+		return sam.PORT.PMUX0_4.Get()
+	case 5:
+		return sam.PORT.PMUX0_5.Get()
+	case 6:
+		return sam.PORT.PMUX0_6.Get()
+	case 7:
+		return sam.PORT.PMUX0_7.Get()
+	case 8:
+		return sam.PORT.PMUX0_8.Get()
+	case 9:
+		return sam.PORT.PMUX0_9.Get()
+	case 10:
+		return sam.PORT.PMUX0_10.Get()
+	case 11:
+		return sam.PORT.PMUX0_11.Get()
+	case 12:
+		return sam.PORT.PMUX0_12.Get()
+	case 13:
+		return sam.PORT.PMUX0_13.Get()
+	case 14:
+		return sam.PORT.PMUX0_14.Get()
+	case 15:
+		return sam.PORT.PMUX0_15.Get()
+	case 16:
+		return uint8(sam.PORT.PMUX1_0.Get()>>0) & 0xff
+	case 17:
+		return uint8(sam.PORT.PMUX1_0.Get()>>8) & 0xff
+	case 18:
+		return uint8(sam.PORT.PMUX1_0.Get()>>16) & 0xff
+	case 19:
+		return uint8(sam.PORT.PMUX1_0.Get()>>24) & 0xff
+	case 20:
+		return uint8(sam.PORT.PMUX1_4.Get()>>0) & 0xff
+	case 21:
+		return uint8(sam.PORT.PMUX1_4.Get()>>8) & 0xff
+	case 22:
+		return uint8(sam.PORT.PMUX1_4.Get()>>16) & 0xff
+	case 23:
+		return uint8(sam.PORT.PMUX1_4.Get()>>24) & 0xff
+	case 24:
+		return uint8(sam.PORT.PMUX1_8.Get()>>0) & 0xff
+	case 25:
+		return uint8(sam.PORT.PMUX1_8.Get()>>8) & 0xff
+	case 26:
+		return uint8(sam.PORT.PMUX1_8.Get()>>16) & 0xff
+	case 27:
+		return uint8(sam.PORT.PMUX1_8.Get()>>24) & 0xff
+	case 28:
+		return uint8(sam.PORT.PMUX1_12.Get()>>0) & 0xff
+	case 29:
+		return uint8(sam.PORT.PMUX1_12.Get()>>8) & 0xff
+	case 30:
+		return uint8(sam.PORT.PMUX1_12.Get()>>16) & 0xff
+	case 31:
+		return uint8(sam.PORT.PMUX1_12.Get()>>24) & 0xff
+	default:
+		return 0
+	}
+}
+
+// setPMux sets the value for the correct PMUX register for this pin.
+func (p Pin) setPMux(val uint8) {
+	switch uint8(p) >> 1 {
+	case 0:
+		sam.PORT.PMUX0_0.Set(val)
+	case 1:
+		sam.PORT.PMUX0_1.Set(val)
+	case 2:
+		sam.PORT.PMUX0_2.Set(val)
+	case 3:
+		sam.PORT.PMUX0_3.Set(val)
+	case 4:
+		sam.PORT.PMUX0_4.Set(val)
+	case 5:
+		sam.PORT.PMUX0_5.Set(val)
+	case 6:
+		sam.PORT.PMUX0_6.Set(val)
+	case 7:
+		sam.PORT.PMUX0_7.Set(val)
+	case 8:
+		sam.PORT.PMUX0_8.Set(val)
+	case 9:
+		sam.PORT.PMUX0_9.Set(val)
+	case 10:
+		sam.PORT.PMUX0_10.Set(val)
+	case 11:
+		sam.PORT.PMUX0_11.Set(val)
+	case 12:
+		sam.PORT.PMUX0_12.Set(val)
+	case 13:
+		sam.PORT.PMUX0_13.Set(val)
+	case 14:
+		sam.PORT.PMUX0_14.Set(val)
+	case 15:
+		sam.PORT.PMUX0_15.Set(val)
+	case 16:
+		sam.PORT.PMUX1_0.Set(sam.PORT.PMUX1_0.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 17:
+		sam.PORT.PMUX1_0.Set(sam.PORT.PMUX1_0.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 18:
+		sam.PORT.PMUX1_0.Set(sam.PORT.PMUX1_0.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 19:
+		sam.PORT.PMUX1_0.Set(sam.PORT.PMUX1_0.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 20:
+		sam.PORT.PMUX1_4.Set(sam.PORT.PMUX1_4.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 21:
+		sam.PORT.PMUX1_4.Set(sam.PORT.PMUX1_4.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 22:
+		sam.PORT.PMUX1_4.Set(sam.PORT.PMUX1_4.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 23:
+		sam.PORT.PMUX1_4.Set(sam.PORT.PMUX1_4.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 24:
+		sam.PORT.PMUX1_8.Set(sam.PORT.PMUX1_8.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 25:
+		sam.PORT.PMUX1_8.Set(sam.PORT.PMUX1_8.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 26:
+		sam.PORT.PMUX1_8.Set(sam.PORT.PMUX1_8.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 27:
+		sam.PORT.PMUX1_8.Set(sam.PORT.PMUX1_8.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 28:
+		sam.PORT.PMUX1_12.Set(sam.PORT.PMUX1_12.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 29:
+		sam.PORT.PMUX1_12.Set(sam.PORT.PMUX1_12.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 30:
+		sam.PORT.PMUX1_12.Set(sam.PORT.PMUX1_12.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 31:
+		sam.PORT.PMUX1_12.Set(sam.PORT.PMUX1_12.Get()&^(0xff<<24) | (uint32(val) << 24))
+	}
+}
+
+// getPinCfg returns the value for the correct PINCFG register for this pin.
+func (p Pin) getPinCfg() uint8 {
+	switch p {
+	case 0:
+		return sam.PORT.PINCFG0_0.Get()
+	case 1:
+		return sam.PORT.PINCFG0_1.Get()
+	case 2:
+		return sam.PORT.PINCFG0_2.Get()
+	case 3:
+		return sam.PORT.PINCFG0_3.Get()
+	case 4:
+		return sam.PORT.PINCFG0_4.Get()
+	case 5:
+		return sam.PORT.PINCFG0_5.Get()
+	case 6:
+		return sam.PORT.PINCFG0_6.Get()
+	case 7:
+		return sam.PORT.PINCFG0_7.Get()
+	case 8:
+		return sam.PORT.PINCFG0_8.Get()
+	case 9:
+		return sam.PORT.PINCFG0_9.Get()
+	case 10:
+		return sam.PORT.PINCFG0_10.Get()
+	case 11:
+		return sam.PORT.PINCFG0_11.Get()
+	case 12:
+		return sam.PORT.PINCFG0_12.Get()
+	case 13:
+		return sam.PORT.PINCFG0_13.Get()
+	case 14:
+		return sam.PORT.PINCFG0_14.Get()
+	case 15:
+		return sam.PORT.PINCFG0_15.Get()
+	case 16:
+		return sam.PORT.PINCFG0_16.Get()
+	case 17:
+		return sam.PORT.PINCFG0_17.Get()
+	case 18:
+		return sam.PORT.PINCFG0_18.Get()
+	case 19:
+		return sam.PORT.PINCFG0_19.Get()
+	case 20:
+		return sam.PORT.PINCFG0_20.Get()
+	case 21:
+		return sam.PORT.PINCFG0_21.Get()
+	case 22:
+		return sam.PORT.PINCFG0_22.Get()
+	case 23:
+		return sam.PORT.PINCFG0_23.Get()
+	case 24:
+		return sam.PORT.PINCFG0_24.Get()
+	case 25:
+		return sam.PORT.PINCFG0_25.Get()
+	case 26:
+		return sam.PORT.PINCFG0_26.Get()
+	case 27:
+		return sam.PORT.PINCFG0_27.Get()
+	case 28:
+		return sam.PORT.PINCFG0_28.Get()
+	case 29:
+		return sam.PORT.PINCFG0_29.Get()
+	case 30:
+		return sam.PORT.PINCFG0_30.Get()
+	case 31:
+		return sam.PORT.PINCFG0_31.Get()
+	case 32: // PB00
+		return uint8(sam.PORT.PINCFG1_0.Get()>>0) & 0xff
+	case 33: // PB01
+		return uint8(sam.PORT.PINCFG1_0.Get()>>8) & 0xff
+	case 34: // PB02
+		return uint8(sam.PORT.PINCFG1_0.Get()>>16) & 0xff
+	case 35: // PB03
+		return uint8(sam.PORT.PINCFG1_0.Get()>>24) & 0xff
+	case 37: // PB04
+		return uint8(sam.PORT.PINCFG1_4.Get()>>0) & 0xff
+	case 38: // PB05
+		return uint8(sam.PORT.PINCFG1_4.Get()>>8) & 0xff
+	case 39: // PB06
+		return uint8(sam.PORT.PINCFG1_4.Get()>>16) & 0xff
+	case 40: // PB07
+		return uint8(sam.PORT.PINCFG1_4.Get()>>24) & 0xff
+	case 41: // PB08
+		return uint8(sam.PORT.PINCFG1_8.Get()>>0) & 0xff
+	case 42: // PB09
+		return uint8(sam.PORT.PINCFG1_8.Get()>>8) & 0xff
+	case 43: // PB10
+		return uint8(sam.PORT.PINCFG1_8.Get()>>16) & 0xff
+	case 44: // PB11
+		return uint8(sam.PORT.PINCFG1_8.Get()>>24) & 0xff
+	case 45: // PB12
+		return uint8(sam.PORT.PINCFG1_12.Get()>>0) & 0xff
+	case 46: // PB13
+		return uint8(sam.PORT.PINCFG1_12.Get()>>8) & 0xff
+	case 47: // PB14
+		return uint8(sam.PORT.PINCFG1_12.Get()>>16) & 0xff
+	case 48: // PB15
+		return uint8(sam.PORT.PINCFG1_12.Get()>>24) & 0xff
+	case 49: // PB16
+		return uint8(sam.PORT.PINCFG1_16.Get()>>0) & 0xff
+	case 50: // PB17
+		return uint8(sam.PORT.PINCFG1_16.Get()>>8) & 0xff
+	case 51: // PB18
+		return uint8(sam.PORT.PINCFG1_16.Get()>>16) & 0xff
+	case 52: // PB19
+		return uint8(sam.PORT.PINCFG1_16.Get()>>24) & 0xff
+	case 53: // PB20
+		return uint8(sam.PORT.PINCFG1_20.Get()>>0) & 0xff
+	case 54: // PB21
+		return uint8(sam.PORT.PINCFG1_20.Get()>>8) & 0xff
+	case 55: // PB22
+		return uint8(sam.PORT.PINCFG1_20.Get()>>16) & 0xff
+	case 56: // PB23
+		return uint8(sam.PORT.PINCFG1_20.Get()>>24) & 0xff
+	case 57: // PB24
+		return uint8(sam.PORT.PINCFG1_24.Get()>>0) & 0xff
+	case 58: // PB25
+		return uint8(sam.PORT.PINCFG1_24.Get()>>8) & 0xff
+	case 59: // PB26
+		return uint8(sam.PORT.PINCFG1_24.Get()>>16) & 0xff
+	case 60: // PB27
+		return uint8(sam.PORT.PINCFG1_24.Get()>>24) & 0xff
+	case 61: // PB28
+		return uint8(sam.PORT.PINCFG1_28.Get()>>0) & 0xff
+	case 62: // PB29
+		return uint8(sam.PORT.PINCFG1_28.Get()>>8) & 0xff
+	case 63: // PB30
+		return uint8(sam.PORT.PINCFG1_28.Get()>>16) & 0xff
+	case 64: // PB31
+		return uint8(sam.PORT.PINCFG1_28.Get()>>24) & 0xff
+	default:
+		return 0
+	}
+}
+
+// setPinCfg sets the value for the correct PINCFG register for this pin.
+func (p Pin) setPinCfg(val uint8) {
+	switch p {
+	case 0:
+		sam.PORT.PINCFG0_0.Set(val)
+	case 1:
+		sam.PORT.PINCFG0_1.Set(val)
+	case 2:
+		sam.PORT.PINCFG0_2.Set(val)
+	case 3:
+		sam.PORT.PINCFG0_3.Set(val)
+	case 4:
+		sam.PORT.PINCFG0_4.Set(val)
+	case 5:
+		sam.PORT.PINCFG0_5.Set(val)
+	case 6:
+		sam.PORT.PINCFG0_6.Set(val)
+	case 7:
+		sam.PORT.PINCFG0_7.Set(val)
+	case 8:
+		sam.PORT.PINCFG0_8.Set(val)
+	case 9:
+		sam.PORT.PINCFG0_9.Set(val)
+	case 10:
+		sam.PORT.PINCFG0_10.Set(val)
+	case 11:
+		sam.PORT.PINCFG0_11.Set(val)
+	case 12:
+		sam.PORT.PINCFG0_12.Set(val)
+	case 13:
+		sam.PORT.PINCFG0_13.Set(val)
+	case 14:
+		sam.PORT.PINCFG0_14.Set(val)
+	case 15:
+		sam.PORT.PINCFG0_15.Set(val)
+	case 16:
+		sam.PORT.PINCFG0_16.Set(val)
+	case 17:
+		sam.PORT.PINCFG0_17.Set(val)
+	case 18:
+		sam.PORT.PINCFG0_18.Set(val)
+	case 19:
+		sam.PORT.PINCFG0_19.Set(val)
+	case 20:
+		sam.PORT.PINCFG0_20.Set(val)
+	case 21:
+		sam.PORT.PINCFG0_21.Set(val)
+	case 22:
+		sam.PORT.PINCFG0_22.Set(val)
+	case 23:
+		sam.PORT.PINCFG0_23.Set(val)
+	case 24:
+		sam.PORT.PINCFG0_24.Set(val)
+	case 25:
+		sam.PORT.PINCFG0_25.Set(val)
+	case 26:
+		sam.PORT.PINCFG0_26.Set(val)
+	case 27:
+		sam.PORT.PINCFG0_27.Set(val)
+	case 28:
+		sam.PORT.PINCFG0_28.Set(val)
+	case 29:
+		sam.PORT.PINCFG0_29.Set(val)
+	case 30:
+		sam.PORT.PINCFG0_30.Set(val)
+	case 31:
+		sam.PORT.PINCFG0_31.Set(val)
+	case 32: // PB00
+		sam.PORT.PINCFG1_0.Set(sam.PORT.PINCFG1_0.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 33: // PB01
+		sam.PORT.PINCFG1_0.Set(sam.PORT.PINCFG1_0.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 34: // PB02
+		sam.PORT.PINCFG1_0.Set(sam.PORT.PINCFG1_0.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 35: // PB03
+		sam.PORT.PINCFG1_0.Set(sam.PORT.PINCFG1_0.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 36: // PB04
+		sam.PORT.PINCFG1_4.Set(sam.PORT.PINCFG1_4.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 37: // PB05
+		sam.PORT.PINCFG1_4.Set(sam.PORT.PINCFG1_4.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 38: // PB06
+		sam.PORT.PINCFG1_4.Set(sam.PORT.PINCFG1_4.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 39: // PB07
+		sam.PORT.PINCFG1_4.Set(sam.PORT.PINCFG1_4.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 40: // PB08
+		sam.PORT.PINCFG1_8.Set(sam.PORT.PINCFG1_8.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 41: // PB09
+		sam.PORT.PINCFG1_8.Set(sam.PORT.PINCFG1_8.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 42: // PB10
+		sam.PORT.PINCFG1_8.Set(sam.PORT.PINCFG1_8.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 43: // PB11
+		sam.PORT.PINCFG1_8.Set(sam.PORT.PINCFG1_8.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 44: // PB12
+		sam.PORT.PINCFG1_12.Set(sam.PORT.PINCFG1_12.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 45: // PB13
+		sam.PORT.PINCFG1_12.Set(sam.PORT.PINCFG1_12.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 46: // PB14
+		sam.PORT.PINCFG1_12.Set(sam.PORT.PINCFG1_12.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 47: // PB15
+		sam.PORT.PINCFG1_12.Set(sam.PORT.PINCFG1_12.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 48: // PB16
+		sam.PORT.PINCFG1_16.Set(sam.PORT.PINCFG1_16.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 49: // PB17
+		sam.PORT.PINCFG1_16.Set(sam.PORT.PINCFG1_16.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 50: // PB18
+		sam.PORT.PINCFG1_16.Set(sam.PORT.PINCFG1_16.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 51: // PB19
+		sam.PORT.PINCFG1_16.Set(sam.PORT.PINCFG1_16.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 52: // PB20
+		sam.PORT.PINCFG1_20.Set(sam.PORT.PINCFG1_20.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 53: // PB21
+		sam.PORT.PINCFG1_20.Set(sam.PORT.PINCFG1_20.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 54: // PB22
+		sam.PORT.PINCFG1_20.Set(sam.PORT.PINCFG1_20.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 55: // PB23
+		sam.PORT.PINCFG1_20.Set(sam.PORT.PINCFG1_20.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 56: // PB24
+		sam.PORT.PINCFG1_24.Set(sam.PORT.PINCFG1_24.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 57: // PB25
+		sam.PORT.PINCFG1_24.Set(sam.PORT.PINCFG1_24.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 58: // PB26
+		sam.PORT.PINCFG1_24.Set(sam.PORT.PINCFG1_24.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 59: // PB27
+		sam.PORT.PINCFG1_24.Set(sam.PORT.PINCFG1_24.Get()&^(0xff<<24) | (uint32(val) << 24))
+	case 60: // PB28
+		sam.PORT.PINCFG1_28.Set(sam.PORT.PINCFG1_28.Get()&^(0xff<<0) | (uint32(val) << 0))
+	case 61: // PB29
+		sam.PORT.PINCFG1_28.Set(sam.PORT.PINCFG1_28.Get()&^(0xff<<8) | (uint32(val) << 8))
+	case 62: // PB30
+		sam.PORT.PINCFG1_28.Set(sam.PORT.PINCFG1_28.Get()&^(0xff<<16) | (uint32(val) << 16))
+	case 63: // PB31
+		sam.PORT.PINCFG1_28.Set(sam.PORT.PINCFG1_28.Get()&^(0xff<<24) | (uint32(val) << 24))
+	}
+}

src/machine/machine_attiny.go

@@ -7,21 +7,21 @@ import (
 )
 
 // Configure sets the pin to input or output.
-func (p GPIO) Configure(config GPIOConfig) {
-	if config.Mode == GPIO_OUTPUT { // set output bit
-		*avr.DDRB |= 1 << p.Pin
+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 &^= 1 << p.Pin
+		avr.DDRB.ClearBits(1 << uint8(p))
 	}
 }
 
-func (p GPIO) getPortMask() (*avr.RegValue, uint8) {
-	return avr.PORTB, 1 << p.Pin
+func (p Pin) getPortMask() (*avr.Register8, uint8) {
+	return avr.PORTB, 1 << uint8(p)
 }
 
 // Get returns the current value of a GPIO pin.
-func (p GPIO) Get() bool {
-	val := *avr.PINB & (1 << p.Pin)
+func (p Pin) Get() bool {
+	val := avr.PINB.Get() & (1 << uint8(p))
 	return (val > 0)
 }
 

src/machine/machine_avr.go

@@ -6,21 +6,21 @@ import (
 	"device/avr"
 )
 
-type GPIOMode uint8
+type PinMode uint8
 
 const (
-	GPIO_INPUT = iota
-	GPIO_OUTPUT
+	PinInput PinMode = iota
+	PinOutput
 )
 
 // Set changes the value of the GPIO pin. The pin must be configured as output.
-func (p GPIO) Set(value bool) {
+func (p Pin) Set(value bool) {
 	if value { // set bits
 		port, mask := p.PortMaskSet()
-		*port = mask
+		port.Set(mask)
 	} else { // clear bits
 		port, mask := p.PortMaskClear()
-		*port = mask
+		port.Set(mask)
 	}
 }
 
@@ -30,9 +30,9 @@ func (p GPIO) Set(value bool) {
 // Warning: there are no separate pin set/clear registers on the AVR. The
 // returned mask is only valid as long as no other pin in the same port has been
 // changed.
-func (p GPIO) PortMaskSet() (*avr.RegValue, avr.RegValue) {
+func (p Pin) PortMaskSet() (*avr.Register8, uint8) {
 	port, mask := p.getPortMask()
-	return port, *port | avr.RegValue(mask)
+	return port, port.Get() | mask
 }
 
 // Return the register and mask to disable a given port. This can be used to
@@ -41,18 +41,18 @@ func (p GPIO) PortMaskSet() (*avr.RegValue, avr.RegValue) {
 // Warning: there are no separate pin set/clear registers on the AVR. The
 // returned mask is only valid as long as no other pin in the same port has been
 // changed.
-func (p GPIO) PortMaskClear() (*avr.RegValue, avr.RegValue) {
+func (p Pin) PortMaskClear() (*avr.Register8, uint8) {
 	port, mask := p.getPortMask()
-	return port, *port &^ avr.RegValue(mask)
+	return port, port.Get() &^ mask
 }
 
 // InitADC initializes the registers needed for ADC.
 func InitADC() {
 	// set a2d prescaler so we are inside the desired 50-200 KHz range at 16MHz.
-	*avr.ADCSRA |= (avr.ADCSRA_ADPS2 | avr.ADCSRA_ADPS1 | avr.ADCSRA_ADPS0)
+	avr.ADCSRA.SetBits(avr.ADCSRA_ADPS2 | avr.ADCSRA_ADPS1 | avr.ADCSRA_ADPS0)
 
 	// enable a2d conversions
-	*avr.ADCSRA |= avr.ADCSRA_ADEN
+	avr.ADCSRA.SetBits(avr.ADCSRA_ADEN)
 }
 
 // Configure configures a ADCPin to be able to be used to read data.
@@ -68,18 +68,16 @@ func (a ADC) Get() uint16 {
 	// set the ADLAR bit (left-adjusted result) to get a value scaled to 16
 	// bits. This has the same effect as shifting the return value left by 6
 	// bits.
-	*avr.ADMUX = avr.RegValue(avr.ADMUX_REFS0 | avr.ADMUX_ADLAR | (a.Pin & 0x07))
+	avr.ADMUX.Set(avr.ADMUX_REFS0 | avr.ADMUX_ADLAR | (uint8(a.Pin) & 0x07))
 
 	// start the conversion
-	*avr.ADCSRA |= avr.ADCSRA_ADSC
+	avr.ADCSRA.SetBits(avr.ADCSRA_ADSC)
 
 	// ADSC is cleared when the conversion finishes
-	for ok := true; ok; ok = (*avr.ADCSRA & avr.ADCSRA_ADSC) > 0 {
+	for ok := true; ok; ok = avr.ADCSRA.HasBits(avr.ADCSRA_ADSC) {
 	}
 
-	low := uint16(*avr.ADCL)
-	high := uint16(*avr.ADCH)
-	return uint16(low) | uint16(high<<8)
+	return uint16(avr.ADCL.Get()) | uint16(avr.ADCH.Get())<<8
 }
 
 // I2C on AVR.

src/machine/machine_dummy.go

@@ -4,37 +4,37 @@ package machine
 
 // Dummy machine package, filled with no-ops.
 
-type GPIOMode uint8
+type PinMode uint8
 
 const (
-	GPIO_INPUT = iota
-	GPIO_OUTPUT
+	PinInput PinMode = iota
+	PinOutput
 )
 
 // Fake LED numbers, for testing.
 const (
-	LED  = LED1
-	LED1 = 0
-	LED2 = 0
-	LED3 = 0
-	LED4 = 0
+	LED  Pin = LED1
+	LED1 Pin = 0
+	LED2 Pin = 0
+	LED3 Pin = 0
+	LED4 Pin = 0
 )
 
 // Fake button numbers, for testing.
 const (
-	BUTTON  = BUTTON1
-	BUTTON1 = 0
-	BUTTON2 = 0
-	BUTTON3 = 0
-	BUTTON4 = 0
+	BUTTON  Pin = BUTTON1
+	BUTTON1 Pin = 0
+	BUTTON2 Pin = 0
+	BUTTON3 Pin = 0
+	BUTTON4 Pin = 0
 )
 
-func (p GPIO) Configure(config GPIOConfig) {
+func (p Pin) Configure(config PinConfig) {
 }
 
-func (p GPIO) Set(value bool) {
+func (p Pin) Set(value bool) {
 }
 
-func (p GPIO) Get() bool {
+func (p Pin) Get() bool {
 	return false
 }

src/machine/machine_nrf.go

@@ -7,51 +7,51 @@ import (
 	"device/nrf"
 )
 
-type GPIOMode uint8
+type PinMode uint8
 
 const (
-	GPIO_INPUT          = (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	GPIO_INPUT_PULLUP   = GPIO_INPUT | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	GPIO_INPUT_PULLDOWN = GPIO_INPUT | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	GPIO_OUTPUT         = (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInput         PinMode = (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup   PinMode = PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown PinMode = PinOutput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	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)
 )
 
 // Configure this pin with the given configuration.
-func (p GPIO) Configure(config GPIOConfig) {
+func (p Pin) Configure(config PinConfig) {
 	cfg := config.Mode | nrf.GPIO_PIN_CNF_DRIVE_S0S1 | nrf.GPIO_PIN_CNF_SENSE_Disabled
 	port, pin := p.getPortPin()
-	port.PIN_CNF[pin] = nrf.RegValue(cfg)
+	port.PIN_CNF[pin].Set(uint32(cfg))
 }
 
 // Set the pin to high or low.
 // Warning: only use this on an output pin!
-func (p GPIO) Set(high bool) {
+func (p Pin) Set(high bool) {
 	port, pin := p.getPortPin()
 	if high {
-		port.OUTSET = 1 << pin
+		port.OUTSET.Set(1 << pin)
 	} else {
-		port.OUTCLR = 1 << pin
+		port.OUTCLR.Set(1 << pin)
 	}
 }
 
 // Return the register and mask to enable a given GPIO pin. This can be used to
 // implement bit-banged drivers.
-func (p GPIO) PortMaskSet() (*uint32, uint32) {
+func (p Pin) PortMaskSet() (*uint32, uint32) {
 	port, pin := p.getPortPin()
-	return (*uint32)(&port.OUTSET), 1 << pin
+	return &port.OUTSET.Reg, 1 << pin
 }
 
 // Return the register and mask to disable a given port. This can be used to
 // implement bit-banged drivers.
-func (p GPIO) PortMaskClear() (*uint32, uint32) {
+func (p Pin) PortMaskClear() (*uint32, uint32) {
 	port, pin := p.getPortPin()
-	return (*uint32)(&port.OUTCLR), 1 << pin
+	return &port.OUTCLR.Reg, 1 << pin
 }
 
 // Get returns the current value of a GPIO pin.
-func (p GPIO) Get() bool {
+func (p Pin) Get() bool {
 	port, pin := p.getPortPin()
-	return (port.IN>>pin)&1 != 0
+	return (port.IN.Get()>>pin)&1 != 0
 }
 
 // UART on the NRF.
@@ -77,10 +77,10 @@ func (uart UART) Configure(config UARTConfig) {
 	// Set TX and RX pins from board.
 	uart.setPins(UART_TX_PIN, UART_RX_PIN)
 
-	nrf.UART0.ENABLE = nrf.UART_ENABLE_ENABLE_Enabled
-	nrf.UART0.TASKS_STARTTX = 1
-	nrf.UART0.TASKS_STARTRX = 1
-	nrf.UART0.INTENSET = nrf.UART_INTENSET_RXDRDY_Msk
+	nrf.UART0.ENABLE.Set(nrf.UART_ENABLE_ENABLE_Enabled)
+	nrf.UART0.TASKS_STARTTX.Set(1)
+	nrf.UART0.TASKS_STARTRX.Set(1)
+	nrf.UART0.INTENSET.Set(nrf.UART_INTENSET_RXDRDY_Msk)
 
 	// Enable RX IRQ.
 	arm.SetPriority(nrf.IRQ_UART0, 0xc0) // low priority
@@ -99,22 +99,22 @@ func (uart UART) SetBaudRate(br uint32) {
 	// https://devzone.nordicsemi.com/f/nordic-q-a/391/uart-baudrate-register-values/2046#2046
 	rate := uint32((uint64(br/400)*uint64(400*0xffffffff/16000000) + 0x800) & 0xffffff000)
 
-	nrf.UART0.BAUDRATE = nrf.RegValue(rate)
+	nrf.UART0.BAUDRATE.Set(rate)
 }
 
 // WriteByte writes a byte of data to the UART.
 func (uart UART) WriteByte(c byte) error {
-	nrf.UART0.EVENTS_TXDRDY = 0
-	nrf.UART0.TXD = nrf.RegValue(c)
-	for nrf.UART0.EVENTS_TXDRDY == 0 {
+	nrf.UART0.EVENTS_TXDRDY.Set(0)
+	nrf.UART0.TXD.Set(uint32(c))
+	for nrf.UART0.EVENTS_TXDRDY.Get() == 0 {
 	}
 	return nil
 }
 
 func (uart UART) handleInterrupt() {
-	if nrf.UART0.EVENTS_RXDRDY != 0 {
-		uart.Receive(byte(nrf.UART0.RXD))
-		nrf.UART0.EVENTS_RXDRDY = 0x0
+	if nrf.UART0.EVENTS_RXDRDY.Get() != 0 {
+		uart.Receive(byte(nrf.UART0.RXD.Get()))
+		nrf.UART0.EVENTS_RXDRDY.Set(0x0)
 	}
 }
 
@@ -132,8 +132,8 @@ var (
 // I2CConfig is used to store config info for I2C.
 type I2CConfig struct {
 	Frequency uint32
-	SCL       uint8
-	SDA       uint8
+	SCL       Pin
+	SDA       Pin
 }
 
 // Configure is intended to setup the I2C interface.
@@ -149,27 +149,27 @@ func (i2c I2C) Configure(config I2CConfig) {
 	}
 
 	// do config
-	sclPort, sclPin := GPIO{config.SCL}.getPortPin()
-	sclPort.PIN_CNF[sclPin] = (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) |
+	sclPort, sclPin := config.SCL.getPortPin()
+	sclPort.PIN_CNF[sclPin].Set((nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) |
 		(nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos) |
 		(nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos) |
 		(nrf.GPIO_PIN_CNF_DRIVE_S0D1 << nrf.GPIO_PIN_CNF_DRIVE_Pos) |
-		(nrf.GPIO_PIN_CNF_SENSE_Disabled << nrf.GPIO_PIN_CNF_SENSE_Pos)
+		(nrf.GPIO_PIN_CNF_SENSE_Disabled << nrf.GPIO_PIN_CNF_SENSE_Pos))
 
-	sdaPort, sdaPin := GPIO{config.SDA}.getPortPin()
-	sdaPort.PIN_CNF[sdaPin] = (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) |
+	sdaPort, sdaPin := config.SDA.getPortPin()
+	sdaPort.PIN_CNF[sdaPin].Set((nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) |
 		(nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos) |
 		(nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos) |
 		(nrf.GPIO_PIN_CNF_DRIVE_S0D1 << nrf.GPIO_PIN_CNF_DRIVE_Pos) |
-		(nrf.GPIO_PIN_CNF_SENSE_Disabled << nrf.GPIO_PIN_CNF_SENSE_Pos)
+		(nrf.GPIO_PIN_CNF_SENSE_Disabled << nrf.GPIO_PIN_CNF_SENSE_Pos))
 
 	if config.Frequency == TWI_FREQ_400KHZ {
-		i2c.Bus.FREQUENCY = nrf.TWI_FREQUENCY_FREQUENCY_K400
+		i2c.Bus.FREQUENCY.Set(nrf.TWI_FREQUENCY_FREQUENCY_K400)
 	} else {
-		i2c.Bus.FREQUENCY = nrf.TWI_FREQUENCY_FREQUENCY_K100
+		i2c.Bus.FREQUENCY.Set(nrf.TWI_FREQUENCY_FREQUENCY_K100)
 	}
 
-	i2c.Bus.ENABLE = nrf.TWI_ENABLE_ENABLE_Enabled
+	i2c.Bus.ENABLE.Set(nrf.TWI_ENABLE_ENABLE_Enabled)
 	i2c.setPins(config.SCL, config.SDA)
 }
 
@@ -177,29 +177,28 @@ func (i2c I2C) Configure(config I2CConfig) {
 // It clocks out the given address, writes the bytes in w, reads back len(r)
 // bytes and stores them in r, and generates a stop condition on the bus.
 func (i2c I2C) Tx(addr uint16, w, r []byte) error {
-	i2c.Bus.ADDRESS = nrf.RegValue(addr)
+	i2c.Bus.ADDRESS.Set(uint32(addr))
 	if len(w) != 0 {
-		i2c.Bus.TASKS_STARTTX = 1 // start transmission for writing
+		i2c.Bus.TASKS_STARTTX.Set(1) // start transmission for writing
 		for _, b := range w {
 			i2c.writeByte(b)
 		}
 	}
 	if len(r) != 0 {
-		i2c.Bus.TASKS_STARTRX = 1 // re-start transmission for reading
-		for i := range r {        // read each char
+		// To trigger suspend task when a byte is received
+		i2c.Bus.SHORTS.Set(nrf.TWI_SHORTS_BB_SUSPEND)
+		i2c.Bus.TASKS_STARTRX.Set(1) // re-start transmission for reading
+		for i := range r {           // read each char
 			if i+1 == len(r) {
-				// The 'stop' signal must be sent before reading back the last
-				// byte, so that it will be sent by the I2C peripheral right
-				// after the last byte has been read.
-				r[i] = i2c.readLastByte()
-			} else {
-				r[i] = i2c.readByte()
+				// To trigger stop task when last byte is received, set before resume task.
+				i2c.Bus.SHORTS.Set(nrf.TWI_SHORTS_BB_STOP)
 			}
+			i2c.Bus.TASKS_RESUME.Set(1) // re-start transmission for reading
+			r[i] = i2c.readByte()
 		}
-	} else {
-		// Nothing to read back. Stop the transmission.
-		i2c.signalStop()
 	}
+	i2c.signalStop()
+	i2c.Bus.SHORTS.Set(nrf.TWI_SHORTS_BB_SUSPEND_Disabled)
 	return nil
 }
 
@@ -207,36 +206,26 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 // it must generate a stop condition after the next character is retrieved when
 // reading.
 func (i2c I2C) signalStop() {
-	i2c.Bus.TASKS_STOP = 1
-	for i2c.Bus.EVENTS_STOPPED == 0 {
+	i2c.Bus.TASKS_STOP.Set(1)
+	for i2c.Bus.EVENTS_STOPPED.Get() == 0 {
 	}
-	i2c.Bus.EVENTS_STOPPED = 0
+	i2c.Bus.EVENTS_STOPPED.Set(0)
 }
 
 // writeByte writes a single byte to the I2C bus.
 func (i2c I2C) writeByte(data byte) {
-	i2c.Bus.TXD = nrf.RegValue(data)
-	for i2c.Bus.EVENTS_TXDSENT == 0 {
+	i2c.Bus.TXD.Set(uint32(data))
+	for i2c.Bus.EVENTS_TXDSENT.Get() == 0 {
 	}
-	i2c.Bus.EVENTS_TXDSENT = 0
+	i2c.Bus.EVENTS_TXDSENT.Set(0)
 }
 
 // readByte reads a single byte from the I2C bus.
 func (i2c I2C) readByte() byte {
-	for i2c.Bus.EVENTS_RXDREADY == 0 {
+	for i2c.Bus.EVENTS_RXDREADY.Get() == 0 {
 	}
-	i2c.Bus.EVENTS_RXDREADY = 0
-	return byte(i2c.Bus.RXD)
-}
-
-// readLastByte reads a single byte from the I2C bus, sending a stop signal
-// after it has been read.
-func (i2c I2C) readLastByte() byte {
-	for i2c.Bus.EVENTS_RXDREADY == 0 {
-	}
-	i2c.Bus.EVENTS_RXDREADY = 0
-	i2c.signalStop() // signal 'stop' now, so it is sent when reading RXD
-	return byte(i2c.Bus.RXD)
+	i2c.Bus.EVENTS_RXDREADY.Set(0)
+	return byte(i2c.Bus.RXD.Get())
 }
 
 // SPI on the NRF.
@@ -253,9 +242,9 @@ var (
 // SPIConfig is used to store config info for SPI.
 type SPIConfig struct {
 	Frequency uint32
-	SCK       uint8
-	MOSI      uint8
-	MISO      uint8
+	SCK       Pin
+	MOSI      Pin
+	MISO      Pin
 	LSBFirst  bool
 	Mode      uint8
 }
@@ -263,7 +252,7 @@ type SPIConfig struct {
 // Configure is intended to setup the SPI interface.
 func (spi SPI) Configure(config SPIConfig) {
 	// Disable bus to configure it
-	spi.Bus.ENABLE = nrf.SPI_ENABLE_ENABLE_Disabled
+	spi.Bus.ENABLE.Set(nrf.SPI_ENABLE_ENABLE_Disabled)
 
 	// set frequency
 	var freq uint32
@@ -286,7 +275,7 @@ func (spi SPI) Configure(config SPIConfig) {
 	default:
 		freq = nrf.SPI_FREQUENCY_FREQUENCY_K500
 	}
-	spi.Bus.FREQUENCY = nrf.RegValue(freq)
+	spi.Bus.FREQUENCY.Set(freq)
 
 	var conf uint32
 
@@ -313,22 +302,22 @@ func (spi SPI) Configure(config SPIConfig) {
 		conf &^= (nrf.SPI_CONFIG_CPOL_ActiveHigh << nrf.SPI_CONFIG_CPOL_Pos)
 		conf &^= (nrf.SPI_CONFIG_CPHA_Leading << nrf.SPI_CONFIG_CPHA_Pos)
 	}
-	spi.Bus.CONFIG = nrf.RegValue(conf)
+	spi.Bus.CONFIG.Set(conf)
 
 	// set pins
 	spi.setPins(config.SCK, config.MOSI, config.MISO)
 
 	// Re-enable bus now that it is configured.
-	spi.Bus.ENABLE = nrf.SPI_ENABLE_ENABLE_Enabled
+	spi.Bus.ENABLE.Set(nrf.SPI_ENABLE_ENABLE_Enabled)
 }
 
 // Transfer writes/reads a single byte using the SPI interface.
 func (spi SPI) Transfer(w byte) (byte, error) {
-	spi.Bus.TXD = nrf.RegValue(w)
-	for spi.Bus.EVENTS_READY == 0 {
+	spi.Bus.TXD.Set(uint32(w))
+	for spi.Bus.EVENTS_READY.Get() == 0 {
 	}
-	r := spi.Bus.RXD
-	spi.Bus.EVENTS_READY = 0
+	r := spi.Bus.RXD.Get()
+	spi.Bus.EVENTS_READY.Set(0)
 
 	// TODO: handle SPI errors
 	return byte(r), nil

src/machine/machine_nrf51.go

@@ -9,13 +9,13 @@ import (
 const CPU_FREQUENCY = 16000000
 
 // Get peripheral and pin number for this GPIO pin.
-func (p GPIO) getPortPin() (*nrf.GPIO_Type, uint8) {
-	return nrf.GPIO, p.Pin
+func (p Pin) getPortPin() (*nrf.GPIO_Type, uint32) {
+	return nrf.GPIO, uint32(p)
 }
 
-func (uart UART) setPins(tx, rx uint32) {
-	nrf.UART0.PSELTXD = nrf.RegValue(tx)
-	nrf.UART0.PSELRXD = nrf.RegValue(rx)
+func (uart UART) setPins(tx, rx Pin) {
+	nrf.UART0.PSELTXD.Set(uint32(tx))
+	nrf.UART0.PSELRXD.Set(uint32(rx))
 }
 
 //go:export UART0_IRQHandler
@@ -23,13 +23,13 @@ func handleUART0() {
 	UART0.handleInterrupt()
 }
 
-func (i2c I2C) setPins(scl, sda uint8) {
-	i2c.Bus.PSELSCL = nrf.RegValue(scl)
-	i2c.Bus.PSELSDA = nrf.RegValue(sda)
+func (i2c I2C) setPins(scl, sda Pin) {
+	i2c.Bus.PSELSCL.Set(uint32(scl))
+	i2c.Bus.PSELSDA.Set(uint32(sda))
 }
 
 // SPI
-func (spi SPI) setPins(sck, mosi, miso uint8) {
+func (spi SPI) setPins(sck, mosi, miso Pin) {
 	if sck == 0 {
 		sck = SPI0_SCK_PIN
 	}
@@ -39,7 +39,7 @@ func (spi SPI) setPins(sck, mosi, miso uint8) {
 	if miso == 0 {
 		miso = SPI0_MISO_PIN
 	}
-	spi.Bus.PSELSCK = nrf.RegValue(sck)
-	spi.Bus.PSELMOSI = nrf.RegValue(mosi)
-	spi.Bus.PSELMISO = nrf.RegValue(miso)
+	spi.Bus.PSELSCK.Set(uint32(sck))
+	spi.Bus.PSELMOSI.Set(uint32(mosi))
+	spi.Bus.PSELMISO.Set(uint32(miso))
 }

src/machine/machine_nrf52.go

@@ -10,13 +10,13 @@ import (
 const CPU_FREQUENCY = 64000000
 
 // Get peripheral and pin number for this GPIO pin.
-func (p GPIO) getPortPin() (*nrf.GPIO_Type, uint8) {
-	return nrf.P0, p.Pin
+func (p Pin) getPortPin() (*nrf.GPIO_Type, uint32) {
+	return nrf.P0, uint32(p)
 }
 
-func (uart UART) setPins(tx, rx uint32) {
-	nrf.UART0.PSELTXD = nrf.RegValue(tx)
-	nrf.UART0.PSELRXD = nrf.RegValue(rx)
+func (uart UART) setPins(tx, rx Pin) {
+	nrf.UART0.PSELTXD.Set(uint32(tx))
+	nrf.UART0.PSELRXD.Set(uint32(rx))
 }
 
 //go:export UARTE0_UART0_IRQHandler
@@ -24,13 +24,13 @@ func handleUART0() {
 	UART0.handleInterrupt()
 }
 
-func (i2c I2C) setPins(scl, sda uint8) {
-	i2c.Bus.PSELSCL = nrf.RegValue(scl)
-	i2c.Bus.PSELSDA = nrf.RegValue(sda)
+func (i2c I2C) setPins(scl, sda Pin) {
+	i2c.Bus.PSELSCL.Set(uint32(scl))
+	i2c.Bus.PSELSDA.Set(uint32(sda))
 }
 
 // SPI
-func (spi SPI) setPins(sck, mosi, miso uint8) {
+func (spi SPI) setPins(sck, mosi, miso Pin) {
 	if sck == 0 {
 		sck = SPI0_SCK_PIN
 	}
@@ -40,9 +40,9 @@ func (spi SPI) setPins(sck, mosi, miso uint8) {
 	if miso == 0 {
 		miso = SPI0_MISO_PIN
 	}
-	spi.Bus.PSEL.SCK = nrf.RegValue(sck)
-	spi.Bus.PSEL.MOSI = nrf.RegValue(mosi)
-	spi.Bus.PSEL.MISO = nrf.RegValue(miso)
+	spi.Bus.PSEL.SCK.Set(uint32(sck))
+	spi.Bus.PSEL.MOSI.Set(uint32(mosi))
+	spi.Bus.PSEL.MISO.Set(uint32(miso))
 }
 
 // InitADC initializes the registers needed for ADC.
@@ -89,53 +89,53 @@ func (a ADC) Get() uint16 {
 		return 0
 	}
 
-	nrf.SAADC.RESOLUTION = nrf.SAADC_RESOLUTION_VAL_12bit
+	nrf.SAADC.RESOLUTION.Set(nrf.SAADC_RESOLUTION_VAL_12bit)
 
 	// Enable ADC.
-	nrf.SAADC.ENABLE = (nrf.SAADC_ENABLE_ENABLE_Enabled << nrf.SAADC_ENABLE_ENABLE_Pos)
+	nrf.SAADC.ENABLE.Set(nrf.SAADC_ENABLE_ENABLE_Enabled << nrf.SAADC_ENABLE_ENABLE_Pos)
 	for i := 0; i < 8; i++ {
-		nrf.SAADC.CH[i].PSELN = nrf.SAADC_CH_PSELP_PSELP_NC
-		nrf.SAADC.CH[i].PSELP = nrf.SAADC_CH_PSELP_PSELP_NC
+		nrf.SAADC.CH[i].PSELN.Set(nrf.SAADC_CH_PSELP_PSELP_NC)
+		nrf.SAADC.CH[i].PSELP.Set(nrf.SAADC_CH_PSELP_PSELP_NC)
 	}
 
 	// Configure ADC.
-	nrf.SAADC.CH[0].CONFIG = ((nrf.SAADC_CH_CONFIG_RESP_Bypass << nrf.SAADC_CH_CONFIG_RESP_Pos) & nrf.SAADC_CH_CONFIG_RESP_Msk) |
+	nrf.SAADC.CH[0].CONFIG.Set(((nrf.SAADC_CH_CONFIG_RESP_Bypass << nrf.SAADC_CH_CONFIG_RESP_Pos) & nrf.SAADC_CH_CONFIG_RESP_Msk) |
 		((nrf.SAADC_CH_CONFIG_RESP_Bypass << nrf.SAADC_CH_CONFIG_RESN_Pos) & nrf.SAADC_CH_CONFIG_RESN_Msk) |
 		((nrf.SAADC_CH_CONFIG_GAIN_Gain1_5 << nrf.SAADC_CH_CONFIG_GAIN_Pos) & nrf.SAADC_CH_CONFIG_GAIN_Msk) |
 		((nrf.SAADC_CH_CONFIG_REFSEL_Internal << nrf.SAADC_CH_CONFIG_REFSEL_Pos) & nrf.SAADC_CH_CONFIG_REFSEL_Msk) |
 		((nrf.SAADC_CH_CONFIG_TACQ_3us << nrf.SAADC_CH_CONFIG_TACQ_Pos) & nrf.SAADC_CH_CONFIG_TACQ_Msk) |
-		((nrf.SAADC_CH_CONFIG_MODE_SE << nrf.SAADC_CH_CONFIG_MODE_Pos) & nrf.SAADC_CH_CONFIG_MODE_Msk)
+		((nrf.SAADC_CH_CONFIG_MODE_SE << nrf.SAADC_CH_CONFIG_MODE_Pos) & nrf.SAADC_CH_CONFIG_MODE_Msk))
 
 	// Set pin to read.
-	nrf.SAADC.CH[0].PSELN = nrf.RegValue(pwmPin)
-	nrf.SAADC.CH[0].PSELP = nrf.RegValue(pwmPin)
+	nrf.SAADC.CH[0].PSELN.Set(pwmPin)
+	nrf.SAADC.CH[0].PSELP.Set(pwmPin)
 
 	// Destination for sample result.
-	nrf.SAADC.RESULT.PTR = nrf.RegValue(uintptr(unsafe.Pointer(&value)))
-	nrf.SAADC.RESULT.MAXCNT = 1 // One sample
+	nrf.SAADC.RESULT.PTR.Set(uint32(uintptr(unsafe.Pointer(&value))))
+	nrf.SAADC.RESULT.MAXCNT.Set(1) // One sample
 
 	// Start tasks.
-	nrf.SAADC.TASKS_START = 1
-	for nrf.SAADC.EVENTS_STARTED == 0 {
+	nrf.SAADC.TASKS_START.Set(1)
+	for nrf.SAADC.EVENTS_STARTED.Get() == 0 {
 	}
-	nrf.SAADC.EVENTS_STARTED = 0x00
+	nrf.SAADC.EVENTS_STARTED.Set(0x00)
 
 	// Start the sample task.
-	nrf.SAADC.TASKS_SAMPLE = 1
+	nrf.SAADC.TASKS_SAMPLE.Set(1)
 
 	// Wait until the sample task is done.
-	for nrf.SAADC.EVENTS_END == 0 {
+	for nrf.SAADC.EVENTS_END.Get() == 0 {
 	}
-	nrf.SAADC.EVENTS_END = 0x00
+	nrf.SAADC.EVENTS_END.Set(0x00)
 
 	// Stop the ADC
-	nrf.SAADC.TASKS_STOP = 1
-	for nrf.SAADC.EVENTS_STOPPED == 0 {
+	nrf.SAADC.TASKS_STOP.Set(1)
+	for nrf.SAADC.EVENTS_STOPPED.Get() == 0 {
 	}
-	nrf.SAADC.EVENTS_STOPPED = 0
+	nrf.SAADC.EVENTS_STOPPED.Set(0)
 
 	// Disable the ADC.
-	nrf.SAADC.ENABLE = (nrf.SAADC_ENABLE_ENABLE_Disabled << nrf.SAADC_ENABLE_ENABLE_Pos)
+	nrf.SAADC.ENABLE.Set(nrf.SAADC_ENABLE_ENABLE_Disabled << nrf.SAADC_ENABLE_ENABLE_Pos)
 
 	if value < 0 {
 		value = 0
@@ -170,21 +170,21 @@ func (pwm PWM) Set(value uint16) {
 
 			p := pwms[i]
 
-			p.PSEL.OUT[0] = nrf.RegValue(pwm.Pin)
-			p.PSEL.OUT[1] = nrf.RegValue(pwm.Pin)
-			p.PSEL.OUT[2] = nrf.RegValue(pwm.Pin)
-			p.PSEL.OUT[3] = nrf.RegValue(pwm.Pin)
-			p.ENABLE = (nrf.PWM_ENABLE_ENABLE_Enabled << nrf.PWM_ENABLE_ENABLE_Pos)
-			p.PRESCALER = nrf.PWM_PRESCALER_PRESCALER_DIV_2
-			p.MODE = nrf.PWM_MODE_UPDOWN_Up
-			p.COUNTERTOP = 16384 // frequency
-			p.LOOP = 0
-			p.DECODER = (nrf.PWM_DECODER_LOAD_Common << nrf.PWM_DECODER_LOAD_Pos) | (nrf.PWM_DECODER_MODE_RefreshCount << nrf.PWM_DECODER_MODE_Pos)
-			p.SEQ[0].PTR = nrf.RegValue(uintptr(unsafe.Pointer(&pwmChannelSequence[i])))
-			p.SEQ[0].CNT = 1
-			p.SEQ[0].REFRESH = 1
-			p.SEQ[0].ENDDELAY = 0
-			p.TASKS_SEQSTART[0] = 1
+			p.PSEL.OUT[0].Set(uint32(pwm.Pin))
+			p.PSEL.OUT[1].Set(uint32(pwm.Pin))
+			p.PSEL.OUT[2].Set(uint32(pwm.Pin))
+			p.PSEL.OUT[3].Set(uint32(pwm.Pin))
+			p.ENABLE.Set(nrf.PWM_ENABLE_ENABLE_Enabled << nrf.PWM_ENABLE_ENABLE_Pos)
+			p.PRESCALER.Set(nrf.PWM_PRESCALER_PRESCALER_DIV_2)
+			p.MODE.Set(nrf.PWM_MODE_UPDOWN_Up)
+			p.COUNTERTOP.Set(16384) // frequency
+			p.LOOP.Set(0)
+			p.DECODER.Set((nrf.PWM_DECODER_LOAD_Common << nrf.PWM_DECODER_LOAD_Pos) | (nrf.PWM_DECODER_MODE_RefreshCount << nrf.PWM_DECODER_MODE_Pos))
+			p.SEQ[0].PTR.Set(uint32(uintptr(unsafe.Pointer(&pwmChannelSequence[i]))))
+			p.SEQ[0].CNT.Set(1)
+			p.SEQ[0].REFRESH.Set(1)
+			p.SEQ[0].ENDDELAY.Set(0)
+			p.TASKS_SEQSTART[0].Set(1)
 
 			break
 		}

src/machine/machine_nrf52840.go

@@ -10,17 +10,17 @@ import (
 const CPU_FREQUENCY = 64000000
 
 // Get peripheral and pin number for this GPIO pin.
-func (p GPIO) getPortPin() (*nrf.GPIO_Type, uint8) {
-	if p.Pin >= 32 {
-		return nrf.P1, p.Pin - 32
+func (p Pin) getPortPin() (*nrf.GPIO_Type, uint32) {
+	if p >= 32 {
+		return nrf.P1, uint32(p - 32)
 	} else {
-		return nrf.P0, p.Pin
+		return nrf.P0, uint32(p)
 	}
 }
 
-func (uart UART) setPins(tx, rx uint32) {
-	nrf.UART0.PSEL.TXD = nrf.RegValue(tx)
-	nrf.UART0.PSEL.RXD = nrf.RegValue(rx)
+func (uart UART) setPins(tx, rx Pin) {
+	nrf.UART0.PSEL.TXD.Set(uint32(tx))
+	nrf.UART0.PSEL.RXD.Set(uint32(rx))
 }
 
 //go:export UARTE0_UART0_IRQHandler
@@ -28,13 +28,13 @@ func handleUART0() {
 	UART0.handleInterrupt()
 }
 
-func (i2c I2C) setPins(scl, sda uint8) {
-	i2c.Bus.PSEL.SCL = nrf.RegValue(scl)
-	i2c.Bus.PSEL.SDA = nrf.RegValue(sda)
+func (i2c I2C) setPins(scl, sda Pin) {
+	i2c.Bus.PSEL.SCL.Set(uint32(scl))
+	i2c.Bus.PSEL.SDA.Set(uint32(sda))
 }
 
 // SPI
-func (spi SPI) setPins(sck, mosi, miso uint8) {
+func (spi SPI) setPins(sck, mosi, miso Pin) {
 	if sck == 0 {
 		sck = SPI0_SCK_PIN
 	}
@@ -44,9 +44,9 @@ func (spi SPI) setPins(sck, mosi, miso uint8) {
 	if miso == 0 {
 		miso = SPI0_MISO_PIN
 	}
-	spi.Bus.PSEL.SCK = nrf.RegValue(sck)
-	spi.Bus.PSEL.MOSI = nrf.RegValue(mosi)
-	spi.Bus.PSEL.MISO = nrf.RegValue(miso)
+	spi.Bus.PSEL.SCK.Set(uint32(sck))
+	spi.Bus.PSEL.MOSI.Set(uint32(mosi))
+	spi.Bus.PSEL.MISO.Set(uint32(miso))
 }
 
 // InitADC initializes the registers needed for ADC.
@@ -93,53 +93,53 @@ func (a ADC) Get() uint16 {
 		return 0
 	}
 
-	nrf.SAADC.RESOLUTION = nrf.SAADC_RESOLUTION_VAL_12bit
+	nrf.SAADC.RESOLUTION.Set(nrf.SAADC_RESOLUTION_VAL_12bit)
 
 	// Enable ADC.
-	nrf.SAADC.ENABLE = (nrf.SAADC_ENABLE_ENABLE_Enabled << nrf.SAADC_ENABLE_ENABLE_Pos)
+	nrf.SAADC.ENABLE.Set(nrf.SAADC_ENABLE_ENABLE_Enabled << nrf.SAADC_ENABLE_ENABLE_Pos)
 	for i := 0; i < 8; i++ {
-		nrf.SAADC.CH[i].PSELN = nrf.SAADC_CH_PSELP_PSELP_NC
-		nrf.SAADC.CH[i].PSELP = nrf.SAADC_CH_PSELP_PSELP_NC
+		nrf.SAADC.CH[i].PSELN.Set(nrf.SAADC_CH_PSELP_PSELP_NC)
+		nrf.SAADC.CH[i].PSELP.Set(nrf.SAADC_CH_PSELP_PSELP_NC)
 	}
 
 	// Configure ADC.
-	nrf.SAADC.CH[0].CONFIG = ((nrf.SAADC_CH_CONFIG_RESP_Bypass << nrf.SAADC_CH_CONFIG_RESP_Pos) & nrf.SAADC_CH_CONFIG_RESP_Msk) |
+	nrf.SAADC.CH[0].CONFIG.Set(((nrf.SAADC_CH_CONFIG_RESP_Bypass << nrf.SAADC_CH_CONFIG_RESP_Pos) & nrf.SAADC_CH_CONFIG_RESP_Msk) |
 		((nrf.SAADC_CH_CONFIG_RESP_Bypass << nrf.SAADC_CH_CONFIG_RESN_Pos) & nrf.SAADC_CH_CONFIG_RESN_Msk) |
 		((nrf.SAADC_CH_CONFIG_GAIN_Gain1_5 << nrf.SAADC_CH_CONFIG_GAIN_Pos) & nrf.SAADC_CH_CONFIG_GAIN_Msk) |
 		((nrf.SAADC_CH_CONFIG_REFSEL_Internal << nrf.SAADC_CH_CONFIG_REFSEL_Pos) & nrf.SAADC_CH_CONFIG_REFSEL_Msk) |
 		((nrf.SAADC_CH_CONFIG_TACQ_3us << nrf.SAADC_CH_CONFIG_TACQ_Pos) & nrf.SAADC_CH_CONFIG_TACQ_Msk) |
-		((nrf.SAADC_CH_CONFIG_MODE_SE << nrf.SAADC_CH_CONFIG_MODE_Pos) & nrf.SAADC_CH_CONFIG_MODE_Msk)
+		((nrf.SAADC_CH_CONFIG_MODE_SE << nrf.SAADC_CH_CONFIG_MODE_Pos) & nrf.SAADC_CH_CONFIG_MODE_Msk))
 
 	// Set pin to read.
-	nrf.SAADC.CH[0].PSELN = nrf.RegValue(pwmPin)
-	nrf.SAADC.CH[0].PSELP = nrf.RegValue(pwmPin)
+	nrf.SAADC.CH[0].PSELN.Set(pwmPin)
+	nrf.SAADC.CH[0].PSELP.Set(pwmPin)
 
 	// Destination for sample result.
-	nrf.SAADC.RESULT.PTR = nrf.RegValue(uintptr(unsafe.Pointer(&value)))
-	nrf.SAADC.RESULT.MAXCNT = 1 // One sample
+	nrf.SAADC.RESULT.PTR.Set(uint32(uintptr(unsafe.Pointer(&value))))
+	nrf.SAADC.RESULT.MAXCNT.Set(1) // One sample
 
 	// Start tasks.
-	nrf.SAADC.TASKS_START = 1
-	for nrf.SAADC.EVENTS_STARTED == 0 {
+	nrf.SAADC.TASKS_START.Set(1)
+	for nrf.SAADC.EVENTS_STARTED.Get() == 0 {
 	}
-	nrf.SAADC.EVENTS_STARTED = 0x00
+	nrf.SAADC.EVENTS_STARTED.Set(0x00)
 
 	// Start the sample task.
-	nrf.SAADC.TASKS_SAMPLE = 1
+	nrf.SAADC.TASKS_SAMPLE.Set(1)
 
 	// Wait until the sample task is done.
-	for nrf.SAADC.EVENTS_END == 0 {
+	for nrf.SAADC.EVENTS_END.Get() == 0 {
 	}
-	nrf.SAADC.EVENTS_END = 0x00
+	nrf.SAADC.EVENTS_END.Set(0x00)
 
 	// Stop the ADC
-	nrf.SAADC.TASKS_STOP = 1
-	for nrf.SAADC.EVENTS_STOPPED == 0 {
+	nrf.SAADC.TASKS_STOP.Set(1)
+	for nrf.SAADC.EVENTS_STOPPED.Get() == 0 {
 	}
-	nrf.SAADC.EVENTS_STOPPED = 0
+	nrf.SAADC.EVENTS_STOPPED.Set(0)
 
 	// Disable the ADC.
-	nrf.SAADC.ENABLE = (nrf.SAADC_ENABLE_ENABLE_Disabled << nrf.SAADC_ENABLE_ENABLE_Pos)
+	nrf.SAADC.ENABLE.Set(nrf.SAADC_ENABLE_ENABLE_Disabled << nrf.SAADC_ENABLE_ENABLE_Pos)
 
 	if value < 0 {
 		value = 0
@@ -174,21 +174,21 @@ func (pwm PWM) Set(value uint16) {
 
 			p := pwms[i]
 
-			p.PSEL.OUT[0] = nrf.RegValue(pwm.Pin)
-			p.PSEL.OUT[1] = nrf.RegValue(pwm.Pin)
-			p.PSEL.OUT[2] = nrf.RegValue(pwm.Pin)
-			p.PSEL.OUT[3] = nrf.RegValue(pwm.Pin)
-			p.ENABLE = (nrf.PWM_ENABLE_ENABLE_Enabled << nrf.PWM_ENABLE_ENABLE_Pos)
-			p.PRESCALER = nrf.PWM_PRESCALER_PRESCALER_DIV_2
-			p.MODE = nrf.PWM_MODE_UPDOWN_Up
-			p.COUNTERTOP = 16384 // frequency
-			p.LOOP = 0
-			p.DECODER = (nrf.PWM_DECODER_LOAD_Common << nrf.PWM_DECODER_LOAD_Pos) | (nrf.PWM_DECODER_MODE_RefreshCount << nrf.PWM_DECODER_MODE_Pos)
-			p.SEQ[0].PTR = nrf.RegValue(uintptr(unsafe.Pointer(&pwmChannelSequence[i])))
-			p.SEQ[0].CNT = 1
-			p.SEQ[0].REFRESH = 1
-			p.SEQ[0].ENDDELAY = 0
-			p.TASKS_SEQSTART[0] = 1
+			p.PSEL.OUT[0].Set(uint32(pwm.Pin))
+			p.PSEL.OUT[1].Set(uint32(pwm.Pin))
+			p.PSEL.OUT[2].Set(uint32(pwm.Pin))
+			p.PSEL.OUT[3].Set(uint32(pwm.Pin))
+			p.ENABLE.Set(nrf.PWM_ENABLE_ENABLE_Enabled << nrf.PWM_ENABLE_ENABLE_Pos)
+			p.PRESCALER.Set(nrf.PWM_PRESCALER_PRESCALER_DIV_2)
+			p.MODE.Set(nrf.PWM_MODE_UPDOWN_Up)
+			p.COUNTERTOP.Set(16384) // frequency
+			p.LOOP.Set(0)
+			p.DECODER.Set((nrf.PWM_DECODER_LOAD_Common << nrf.PWM_DECODER_LOAD_Pos) | (nrf.PWM_DECODER_MODE_RefreshCount << nrf.PWM_DECODER_MODE_Pos))
+			p.SEQ[0].PTR.Set(uint32(uintptr(unsafe.Pointer(&pwmChannelSequence[i]))))
+			p.SEQ[0].CNT.Set(1)
+			p.SEQ[0].REFRESH.Set(1)
+			p.SEQ[0].ENDDELAY.Set(0)
+			p.TASKS_SEQSTART[0].Set(1)
 
 			break
 		}

src/machine/machine_stm32.go

@@ -4,10 +4,10 @@ package machine
 
 // Peripheral abstraction layer for the stm32.
 
-type GPIOMode uint8
+type PinMode uint8
 
 const (
-	portA = iota * 16
+	portA Pin = iota * 16
 	portB
 	portC
 	portD

src/machine/machine_stm32f103xx.go

@@ -13,25 +13,25 @@ import (
 const CPU_FREQUENCY = 72000000
 
 const (
-	GPIO_INPUT        = 0 // Input mode
-	GPIO_OUTPUT_10MHz = 1 // Output mode, max speed 10MHz
-	GPIO_OUTPUT_2MHz  = 2 // Output mode, max speed 2MHz
-	GPIO_OUTPUT_50MHz = 3 // Output mode, max speed 50MHz
-	GPIO_OUTPUT       = GPIO_OUTPUT_2MHz
+	PinInput       PinMode = 0 // Input mode
+	PinOutput10MHz PinMode = 1 // Output mode, max speed 10MHz
+	PinOutput2MHz  PinMode = 2 // Output mode, max speed 2MHz
+	PinOutput50MHz PinMode = 3 // Output mode, max speed 50MHz
+	PinOutput      PinMode = PinOutput2MHz
 
-	GPIO_INPUT_MODE_ANALOG       = 0  // Input analog mode
-	GPIO_INPUT_MODE_FLOATING     = 4  // Input floating mode
-	GPIO_INPUT_MODE_PULL_UP_DOWN = 8  // Input pull up/down mode
-	GPIO_INPUT_MODE_RESERVED     = 12 // Input mode (reserved)
+	PinInputModeAnalog     PinMode = 0  // Input analog mode
+	PinInputModeFloating   PinMode = 4  // Input floating mode
+	PinInputModePullUpDown PinMode = 8  // Input pull up/down mode
+	PinInputModeReserved   PinMode = 12 // Input mode (reserved)
 
-	GPIO_OUTPUT_MODE_GP_PUSH_PULL   = 0  // Output mode general purpose push/pull
-	GPIO_OUTPUT_MODE_GP_OPEN_DRAIN  = 4  // Output mode general purpose open drain
-	GPIO_OUTPUT_MODE_ALT_PUSH_PULL  = 8  // Output mode alt. purpose push/pull
-	GPIO_OUTPUT_MODE_ALT_OPEN_DRAIN = 12 // Output mode alt. purpose open drain
+	PinOutputModeGPPushPull   PinMode = 0  // Output mode general purpose push/pull
+	PinOutputModeGPOpenDrain  PinMode = 4  // Output mode general purpose open drain
+	PinOutputModeAltPushPull  PinMode = 8  // Output mode alt. purpose push/pull
+	PinOutputModeAltOpenDrain PinMode = 12 // Output mode alt. purpose open drain
 )
 
-func (p GPIO) getPort() *stm32.GPIO_Type {
-	switch p.Pin / 16 {
+func (p Pin) getPort() *stm32.GPIO_Type {
+	switch p / 16 {
 	case 0:
 		return stm32.GPIOA
 	case 1:
@@ -52,50 +52,50 @@ func (p GPIO) getPort() *stm32.GPIO_Type {
 }
 
 // enableClock enables the clock for this desired GPIO port.
-func (p GPIO) enableClock() {
-	switch p.Pin / 16 {
+func (p Pin) enableClock() {
+	switch p / 16 {
 	case 0:
-		stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_IOPAEN
+		stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_IOPAEN)
 	case 1:
-		stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_IOPBEN
+		stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_IOPBEN)
 	case 2:
-		stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_IOPCEN
+		stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_IOPCEN)
 	case 3:
-		stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_IOPDEN
+		stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_IOPDEN)
 	case 4:
-		stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_IOPEEN
+		stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_IOPEEN)
 	case 5:
-		stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_IOPFEN
+		stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_IOPFEN)
 	case 6:
-		stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_IOPGEN
+		stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_IOPGEN)
 	default:
 		panic("machine: unknown port")
 	}
 }
 
 // Configure this pin with the given configuration.
-func (p GPIO) Configure(config GPIOConfig) {
+func (p Pin) Configure(config PinConfig) {
 	// Configure the GPIO pin.
 	p.enableClock()
 	port := p.getPort()
-	pin := p.Pin % 16
-	pos := p.Pin % 8 * 4
+	pin := uint8(p) % 16
+	pos := uint8(p) % 8 * 4
 	if pin < 8 {
-		port.CRL = stm32.RegValue((uint32(port.CRL) &^ (0xf << pos)) | (uint32(config.Mode) << pos))
+		port.CRL.Set((uint32(port.CRL.Get()) &^ (0xf << pos)) | (uint32(config.Mode) << pos))
 	} else {
-		port.CRH = stm32.RegValue((uint32(port.CRH) &^ (0xf << pos)) | (uint32(config.Mode) << pos))
+		port.CRH.Set((uint32(port.CRH.Get()) &^ (0xf << pos)) | (uint32(config.Mode) << pos))
 	}
 }
 
 // Set the pin to high or low.
 // Warning: only use this on an output pin!
-func (p GPIO) Set(high bool) {
+func (p Pin) Set(high bool) {
 	port := p.getPort()
-	pin := p.Pin % 16
+	pin := uint8(p) % 16
 	if high {
-		port.BSRR = 1 << pin
+		port.BSRR.Set(1 << pin)
 	} else {
-		port.BSRR = 1 << (pin + 16)
+		port.BSRR.Set(1 << (pin + 16))
 	}
 }
 
@@ -122,24 +122,24 @@ func (uart UART) Configure(config UARTConfig) {
 	switch config.TX {
 	case PB6:
 		// use alternate TX/RX pins PB6/PB7 via AFIO mapping
-		stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_AFIOEN
-		stm32.AFIO.MAPR |= stm32.AFIO_MAPR_USART1_REMAP
-		GPIO{PB6}.Configure(GPIOConfig{Mode: GPIO_OUTPUT_50MHz + GPIO_OUTPUT_MODE_ALT_PUSH_PULL})
-		GPIO{PB7}.Configure(GPIOConfig{Mode: GPIO_INPUT_MODE_FLOATING})
+		stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_AFIOEN)
+		stm32.AFIO.MAPR.SetBits(stm32.AFIO_MAPR_USART1_REMAP)
+		PB6.Configure(PinConfig{Mode: PinOutput50MHz + PinOutputModeAltPushPull})
+		PB7.Configure(PinConfig{Mode: PinInputModeFloating})
 	default:
 		// use standard TX/RX pins PA9 and PA10
-		GPIO{UART_TX_PIN}.Configure(GPIOConfig{Mode: GPIO_OUTPUT_50MHz + GPIO_OUTPUT_MODE_ALT_PUSH_PULL})
-		GPIO{UART_RX_PIN}.Configure(GPIOConfig{Mode: GPIO_INPUT_MODE_FLOATING})
+		UART_TX_PIN.Configure(PinConfig{Mode: PinOutput50MHz + PinOutputModeAltPushPull})
+		UART_RX_PIN.Configure(PinConfig{Mode: PinInputModeFloating})
 	}
 
 	// Enable USART1 clock
-	stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_USART1EN
+	stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_USART1EN)
 
 	// Set baud rate
 	uart.SetBaudRate(config.BaudRate)
 
 	// Enable USART1 port.
-	stm32.USART1.CR1 = stm32.USART_CR1_TE | stm32.USART_CR1_RE | stm32.USART_CR1_RXNEIE | stm32.USART_CR1_UE
+	stm32.USART1.CR1.Set(stm32.USART_CR1_TE | stm32.USART_CR1_RE | stm32.USART_CR1_RXNEIE | stm32.USART_CR1_UE)
 
 	// Enable RX IRQ.
 	arm.SetPriority(stm32.IRQ_USART1, 0xc0)
@@ -150,21 +150,21 @@ func (uart UART) Configure(config UARTConfig) {
 func (uart UART) SetBaudRate(br uint32) {
 	// first divide by PCLK2 prescaler (div 1) and then desired baudrate
 	divider := CPU_FREQUENCY / br
-	stm32.USART1.BRR = stm32.RegValue(divider)
+	stm32.USART1.BRR.Set(divider)
 }
 
 // WriteByte writes a byte of data to the UART.
 func (uart UART) WriteByte(c byte) error {
-	stm32.USART1.DR = stm32.RegValue(c)
+	stm32.USART1.DR.Set(uint32(c))
 
-	for (stm32.USART1.SR & stm32.USART_SR_TXE) == 0 {
+	for !stm32.USART1.SR.HasBits(stm32.USART_SR_TXE) {
 	}
 	return nil
 }
 
 //go:export USART1_IRQHandler
 func handleUART1() {
-	UART1.Receive(byte((stm32.USART1.DR & 0xFF)))
+	UART1.Receive(byte((stm32.USART1.DR.Get() & 0xFF)))
 }
 
 // SPI on the STM32.
@@ -183,9 +183,9 @@ var (
 // SPIConfig is used to store config info for SPI.
 type SPIConfig struct {
 	Frequency uint32
-	SCK       uint8
-	MOSI      uint8
-	MISO      uint8
+	SCK       Pin
+	MOSI      Pin
+	MISO      Pin
 	LSBFirst  bool
 	Mode      uint8
 }
@@ -198,9 +198,9 @@ type SPIConfig struct {
 // - hardware SS pin?
 func (spi SPI) Configure(config SPIConfig) {
 	// enable clock for SPI
-	stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_SPI1EN
+	stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_SPI1EN)
 
-	var conf uint16
+	var conf uint32
 
 	// set frequency
 	switch config.Frequency {
@@ -250,37 +250,37 @@ func (spi SPI) Configure(config SPIConfig) {
 	conf |= stm32.SPI_Mode_Master
 
 	// now set the configuration
-	spi.Bus.CR1 = stm32.RegValue(conf)
+	spi.Bus.CR1.Set(conf)
 
 	// init pins
 	spi.setPins(config.SCK, config.MOSI, config.MISO)
 
 	// enable SPI interface
-	spi.Bus.CR1 |= stm32.SPI_CR1_SPE
+	spi.Bus.CR1.SetBits(stm32.SPI_CR1_SPE)
 }
 
 // Transfer writes/reads a single byte using the SPI interface.
 func (spi SPI) Transfer(w byte) (byte, error) {
 	// Write data to be transmitted to the SPI data register
-	spi.Bus.DR = stm32.RegValue(w)
+	spi.Bus.DR.Set(uint32(w))
 
 	// Wait until transmit complete
-	for (spi.Bus.SR & stm32.SPI_SR_TXE) == 0 {
+	for !spi.Bus.SR.HasBits(stm32.SPI_SR_TXE) {
 	}
 
 	// Wait until receive complete
-	for (spi.Bus.SR & stm32.SPI_SR_RXNE) == 0 {
+	for !spi.Bus.SR.HasBits(stm32.SPI_SR_RXNE) {
 	}
 
 	// Wait until SPI is not busy
-	for (spi.Bus.SR & stm32.SPI_SR_BSY) > 0 {
+	for spi.Bus.SR.HasBits(stm32.SPI_SR_BSY) {
 	}
 
 	// Return received data from SPI data register
-	return byte(spi.Bus.DR), nil
+	return byte(spi.Bus.DR.Get()), nil
 }
 
-func (spi SPI) setPins(sck, mosi, miso uint8) {
+func (spi SPI) setPins(sck, mosi, miso Pin) {
 	if sck == 0 {
 		sck = SPI0_SCK_PIN
 	}
@@ -291,9 +291,9 @@ func (spi SPI) setPins(sck, mosi, miso uint8) {
 		miso = SPI0_MISO_PIN
 	}
 
-	GPIO{sck}.Configure(GPIOConfig{Mode: GPIO_OUTPUT_50MHz + GPIO_OUTPUT_MODE_ALT_PUSH_PULL})
-	GPIO{mosi}.Configure(GPIOConfig{Mode: GPIO_OUTPUT_50MHz + GPIO_OUTPUT_MODE_ALT_PUSH_PULL})
-	GPIO{miso}.Configure(GPIOConfig{Mode: GPIO_INPUT_MODE_FLOATING})
+	sck.Configure(PinConfig{Mode: PinOutput50MHz + PinOutputModeAltPushPull})
+	mosi.Configure(PinConfig{Mode: PinOutput50MHz + PinOutputModeAltPushPull})
+	miso.Configure(PinConfig{Mode: PinInputModeFloating})
 }
 
 // I2C on the STM32F103xx.
@@ -312,8 +312,8 @@ var (
 // I2CConfig is used to store config info for I2C.
 type I2CConfig struct {
 	Frequency uint32
-	SCL       uint8
-	SDA       uint8
+	SCL       Pin
+	SDA       Pin
 }
 
 // Configure is intended to setup the I2C interface.
@@ -324,26 +324,26 @@ func (i2c I2C) Configure(config I2CConfig) {
 	}
 
 	// enable clock for I2C
-	stm32.RCC.APB1ENR |= stm32.RCC_APB1ENR_I2C1EN
+	stm32.RCC.APB1ENR.SetBits(stm32.RCC_APB1ENR_I2C1EN)
 
 	// I2C1 pins
 	switch config.SDA {
 	case PB9:
 		config.SCL = PB8
 		// use alternate I2C1 pins PB8/PB9 via AFIO mapping
-		stm32.RCC.APB2ENR |= stm32.RCC_APB2ENR_AFIOEN
-		stm32.AFIO.MAPR |= stm32.AFIO_MAPR_I2C1_REMAP
+		stm32.RCC.APB2ENR.SetBits(stm32.RCC_APB2ENR_AFIOEN)
+		stm32.AFIO.MAPR.SetBits(stm32.AFIO_MAPR_I2C1_REMAP)
 	default:
 		// use default I2C1 pins PB6/PB7
 		config.SDA = SDA_PIN
 		config.SCL = SCL_PIN
 	}
 
-	GPIO{config.SDA}.Configure(GPIOConfig{Mode: GPIO_OUTPUT_50MHz + GPIO_OUTPUT_MODE_ALT_OPEN_DRAIN})
-	GPIO{config.SCL}.Configure(GPIOConfig{Mode: GPIO_OUTPUT_50MHz + GPIO_OUTPUT_MODE_ALT_OPEN_DRAIN})
+	config.SDA.Configure(PinConfig{Mode: PinOutput50MHz + PinOutputModeAltOpenDrain})
+	config.SCL.Configure(PinConfig{Mode: PinOutput50MHz + PinOutputModeAltOpenDrain})
 
 	// Disable the selected I2C peripheral to configure
-	i2c.Bus.CR1 &^= stm32.I2C_CR1_PE
+	i2c.Bus.CR1.ClearBits(stm32.I2C_CR1_PE)
 
 	// pclk1 clock speed is main frequency divided by PCK1 prescaler (div 2)
 	pclk1 := uint32(CPU_FREQUENCY / 2)
@@ -351,40 +351,40 @@ func (i2c I2C) Configure(config I2CConfig) {
 	// set freqency range to pclk1 clock speed in Mhz.
 	// aka setting the value 36 means to use 36MhZ clock.
 	pclk1Mhz := pclk1 / 1000000
-	i2c.Bus.CR2 |= stm32.RegValue(pclk1Mhz)
+	i2c.Bus.CR2.SetBits(pclk1Mhz)
 
 	switch config.Frequency {
 	case TWI_FREQ_100KHZ:
 		// Normal mode speed calculation
 		ccr := pclk1 / (config.Frequency * 2)
-		i2c.Bus.CCR = stm32.RegValue(ccr)
+		i2c.Bus.CCR.Set(ccr)
 
 		// duty cycle 2
-		i2c.Bus.CCR &^= stm32.I2C_CCR_DUTY
+		i2c.Bus.CCR.ClearBits(stm32.I2C_CCR_DUTY)
 
 		// frequency standard mode
-		i2c.Bus.CCR &^= stm32.I2C_CCR_F_S
+		i2c.Bus.CCR.ClearBits(stm32.I2C_CCR_F_S)
 
 		// Set Maximum Rise Time for standard mode
-		i2c.Bus.TRISE = stm32.RegValue(pclk1Mhz)
+		i2c.Bus.TRISE.Set(pclk1Mhz)
 
 	case TWI_FREQ_400KHZ:
 		// Fast mode speed calculation
 		ccr := pclk1 / (config.Frequency * 3)
-		i2c.Bus.CCR = stm32.RegValue(ccr)
+		i2c.Bus.CCR.Set(ccr)
 
 		// duty cycle 2
-		i2c.Bus.CCR &^= stm32.I2C_CCR_DUTY
+		i2c.Bus.CCR.ClearBits(stm32.I2C_CCR_DUTY)
 
 		// frequency fast mode
-		i2c.Bus.CCR |= stm32.I2C_CCR_F_S
+		i2c.Bus.CCR.SetBits(stm32.I2C_CCR_F_S)
 
 		// Set Maximum Rise Time for fast mode
-		i2c.Bus.TRISE = stm32.RegValue(((pclk1Mhz * 300) / 1000))
+		i2c.Bus.TRISE.Set(((pclk1Mhz * 300) / 1000))
 	}
 
 	// re-enable the selected I2C peripheral
-	i2c.Bus.CR1 |= stm32.I2C_CR1_PE
+	i2c.Bus.CR1.SetBits(stm32.I2C_CR1_PE)
 }
 
 // Tx does a single I2C transaction at the specified address.
@@ -435,11 +435,11 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// Disable ACK of received data
-			i2c.Bus.CR1 &^= stm32.I2C_CR1_ACK
+			i2c.Bus.CR1.ClearBits(stm32.I2C_CR1_ACK)
 
 			// clear timeout here
 			timeout := i2cTimeout
-			for i2c.Bus.SR2&(stm32.I2C_SR2_MSL|stm32.I2C_SR2_BUSY) == 0 {
+			for !i2c.Bus.SR2.HasBits(stm32.I2C_SR2_MSL | stm32.I2C_SR2_BUSY) {
 				timeout--
 				if timeout == 0 {
 					return errors.New("I2C timeout on read clear address")
@@ -447,10 +447,10 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// Generate stop condition
-			i2c.Bus.CR1 |= stm32.I2C_CR1_STOP
+			i2c.Bus.CR1.SetBits(stm32.I2C_CR1_STOP)
 
 			timeout = i2cTimeout
-			for (i2c.Bus.SR1 & stm32.I2C_SR1_RxNE) == 0 {
+			for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_RxNE) {
 				timeout--
 				if timeout == 0 {
 					return errors.New("I2C timeout on read 1 byte")
@@ -458,17 +458,17 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// Read and return data byte from I2C data register
-			r[0] = byte(i2c.Bus.DR)
+			r[0] = byte(i2c.Bus.DR.Get())
 
 			// wait for stop
 			return i2c.waitForStop()
 
 		case 2:
 			// enable pos
-			i2c.Bus.CR1 |= stm32.I2C_CR1_POS
+			i2c.Bus.CR1.SetBits(stm32.I2C_CR1_POS)
 
 			// Enable ACK of received data
-			i2c.Bus.CR1 |= stm32.I2C_CR1_ACK
+			i2c.Bus.CR1.SetBits(stm32.I2C_CR1_ACK)
 
 			// send address
 			err = i2c.sendAddress(uint8(addr), false)
@@ -478,7 +478,7 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 
 			// clear address here
 			timeout := i2cTimeout
-			for i2c.Bus.SR2&(stm32.I2C_SR2_MSL|stm32.I2C_SR2_BUSY) == 0 {
+			for !i2c.Bus.SR2.HasBits(stm32.I2C_SR2_MSL | stm32.I2C_SR2_BUSY) {
 				timeout--
 				if timeout == 0 {
 					return errors.New("I2C timeout on read clear address")
@@ -486,11 +486,11 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// Disable ACK of received data
-			i2c.Bus.CR1 &^= stm32.I2C_CR1_ACK
+			i2c.Bus.CR1.ClearBits(stm32.I2C_CR1_ACK)
 
 			// wait for btf. we need a longer timeout here than normal.
 			timeout = 1000
-			for (i2c.Bus.SR1 & stm32.I2C_SR1_BTF) == 0 {
+			for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_BTF) {
 				timeout--
 				if timeout == 0 {
 					return errors.New("I2C timeout on read 2 bytes")
@@ -498,18 +498,23 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// Generate stop condition
-			i2c.Bus.CR1 |= stm32.I2C_CR1_STOP
+			i2c.Bus.CR1.SetBits(stm32.I2C_CR1_STOP)
 
 			// read the 2 bytes by reading twice.
-			r[0] = byte(i2c.Bus.DR)
-			r[1] = byte(i2c.Bus.DR)
+			r[0] = byte(i2c.Bus.DR.Get())
+			r[1] = byte(i2c.Bus.DR.Get())
 
 			// wait for stop
-			return i2c.waitForStop()
+			err = i2c.waitForStop()
+
+			//disable pos
+			i2c.Bus.CR1.ClearBits(stm32.I2C_CR1_POS)
+
+			return err
 
 		case 3:
 			// Enable ACK of received data
-			i2c.Bus.CR1 |= stm32.I2C_CR1_ACK
+			i2c.Bus.CR1.SetBits(stm32.I2C_CR1_ACK)
 
 			// send address
 			err = i2c.sendAddress(uint8(addr), false)
@@ -519,7 +524,7 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 
 			// clear address here
 			timeout := i2cTimeout
-			for i2c.Bus.SR2&(stm32.I2C_SR2_MSL|stm32.I2C_SR2_BUSY) == 0 {
+			for !i2c.Bus.SR2.HasBits(stm32.I2C_SR2_MSL | stm32.I2C_SR2_BUSY) {
 				timeout--
 				if timeout == 0 {
 					return errors.New("I2C timeout on read clear address")
@@ -527,11 +532,11 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// Enable ACK of received data
-			i2c.Bus.CR1 |= stm32.I2C_CR1_ACK
+			i2c.Bus.CR1.SetBits(stm32.I2C_CR1_ACK)
 
 			// wait for btf. we need a longer timeout here than normal.
 			timeout = 1000
-			for (i2c.Bus.SR1 & stm32.I2C_SR1_BTF) == 0 {
+			for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_BTF) {
 				timeout--
 				if timeout == 0 {
 					println("I2C timeout on read 3 bytes")
@@ -540,13 +545,13 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// Disable ACK of received data
-			i2c.Bus.CR1 &^= stm32.I2C_CR1_ACK
+			i2c.Bus.CR1.ClearBits(stm32.I2C_CR1_ACK)
 
 			// read the first byte
-			r[0] = byte(i2c.Bus.DR)
+			r[0] = byte(i2c.Bus.DR.Get())
 
 			timeout = 1000
-			for (i2c.Bus.SR1 & stm32.I2C_SR1_BTF) == 0 {
+			for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_BTF) {
 				timeout--
 				if timeout == 0 {
 					return errors.New("I2C timeout on read 3 bytes")
@@ -554,11 +559,11 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// Generate stop condition
-			i2c.Bus.CR1 |= stm32.I2C_CR1_STOP
+			i2c.Bus.CR1.SetBits(stm32.I2C_CR1_STOP)
 
 			// read the last 2 bytes by reading twice.
-			r[1] = byte(i2c.Bus.DR)
-			r[2] = byte(i2c.Bus.DR)
+			r[1] = byte(i2c.Bus.DR.Get())
+			r[2] = byte(i2c.Bus.DR.Get())
 
 			// wait for stop
 			return i2c.waitForStop()
@@ -574,7 +579,7 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 
 			// clear address here
 			timeout := i2cTimeout
-			for i2c.Bus.SR2&(stm32.I2C_SR2_MSL|stm32.I2C_SR2_BUSY) == 0 {
+			for !i2c.Bus.SR2.HasBits(stm32.I2C_SR2_MSL | stm32.I2C_SR2_BUSY) {
 				timeout--
 				if timeout == 0 {
 					return errors.New("I2C timeout on read clear address")
@@ -583,11 +588,11 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 
 			for i := 0; i < len(r)-3; i++ {
 				// Enable ACK of received data
-				i2c.Bus.CR1 |= stm32.I2C_CR1_ACK
+				i2c.Bus.CR1.SetBits(stm32.I2C_CR1_ACK)
 
 				// wait for btf. we need a longer timeout here than normal.
 				timeout = 1000
-				for (i2c.Bus.SR1 & stm32.I2C_SR1_BTF) == 0 {
+				for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_BTF) {
 					timeout--
 					if timeout == 0 {
 						println("I2C timeout on read 3 bytes")
@@ -596,12 +601,12 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 				}
 
 				// read the next byte
-				r[i] = byte(i2c.Bus.DR)
+				r[i] = byte(i2c.Bus.DR.Get())
 			}
 
 			// wait for btf. we need a longer timeout here than normal.
 			timeout = 1000
-			for (i2c.Bus.SR1 & stm32.I2C_SR1_BTF) == 0 {
+			for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_BTF) {
 				timeout--
 				if timeout == 0 {
 					return errors.New("I2C timeout on read more than 3 bytes")
@@ -609,19 +614,19 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// Disable ACK of received data
-			i2c.Bus.CR1 &^= stm32.I2C_CR1_ACK
+			i2c.Bus.CR1.ClearBits(stm32.I2C_CR1_ACK)
 
 			// get third from last byte
-			r[len(r)-3] = byte(i2c.Bus.DR)
+			r[len(r)-3] = byte(i2c.Bus.DR.Get())
 
 			// Generate stop condition
-			i2c.Bus.CR1 |= stm32.I2C_CR1_STOP
+			i2c.Bus.CR1.SetBits(stm32.I2C_CR1_STOP)
 
 			// get second from last byte
-			r[len(r)-2] = byte(i2c.Bus.DR)
+			r[len(r)-2] = byte(i2c.Bus.DR.Get())
 
 			timeout = i2cTimeout
-			for (i2c.Bus.SR1 & stm32.I2C_SR1_RxNE) == 0 {
+			for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_RxNE) {
 				timeout--
 				if timeout == 0 {
 					return errors.New("I2C timeout on read last byte of more than 3")
@@ -629,7 +634,7 @@ func (i2c I2C) Tx(addr uint16, w, r []byte) error {
 			}
 
 			// get last byte
-			r[len(r)-1] = byte(i2c.Bus.DR)
+			r[len(r)-1] = byte(i2c.Bus.DR.Get())
 
 			// wait for stop
 			return i2c.waitForStop()
@@ -645,7 +650,7 @@ const i2cTimeout = 500
 func (i2c I2C) signalStart() error {
 	// Wait until I2C is not busy
 	timeout := i2cTimeout
-	for (i2c.Bus.SR2 & stm32.I2C_SR2_BUSY) > 0 {
+	for i2c.Bus.SR2.HasBits(stm32.I2C_SR2_BUSY) {
 		timeout--
 		if timeout == 0 {
 			return errors.New("I2C busy on start")
@@ -653,14 +658,14 @@ func (i2c I2C) signalStart() error {
 	}
 
 	// clear stop
-	i2c.Bus.CR1 &^= stm32.I2C_CR1_STOP
+	i2c.Bus.CR1.ClearBits(stm32.I2C_CR1_STOP)
 
 	// Generate start condition
-	i2c.Bus.CR1 |= stm32.I2C_CR1_START
+	i2c.Bus.CR1.SetBits(stm32.I2C_CR1_START)
 
 	// Wait for I2C EV5 aka SB flag.
 	timeout = i2cTimeout
-	for (i2c.Bus.SR1 & stm32.I2C_SR1_SB) == 0 {
+	for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_SB) {
 		timeout--
 		if timeout == 0 {
 			return errors.New("I2C timeout on start")
@@ -673,7 +678,7 @@ func (i2c I2C) signalStart() error {
 // signalStop sends a stop signal and waits for it to succeed.
 func (i2c I2C) signalStop() error {
 	// Generate stop condition
-	i2c.Bus.CR1 |= stm32.I2C_CR1_STOP
+	i2c.Bus.CR1.SetBits(stm32.I2C_CR1_STOP)
 
 	// wait for stop
 	return i2c.waitForStop()
@@ -683,7 +688,7 @@ func (i2c I2C) signalStop() error {
 func (i2c I2C) waitForStop() error {
 	// Wait until I2C is stopped
 	timeout := i2cTimeout
-	for (i2c.Bus.SR1 & stm32.I2C_SR1_STOPF) > 0 {
+	for i2c.Bus.SR1.HasBits(stm32.I2C_SR1_STOPF) {
 		timeout--
 		if timeout == 0 {
 			println("I2C timeout on wait for stop signal")
@@ -701,14 +706,14 @@ func (i2c I2C) sendAddress(address uint8, write bool) error {
 		data |= 1 // set read flag
 	}
 
-	i2c.Bus.DR = stm32.RegValue(data)
+	i2c.Bus.DR.Set(uint32(data))
 
 	// Wait for I2C EV6 event.
 	// Destination device acknowledges address
 	timeout := i2cTimeout
 	if write {
 		// EV6 which is ADDR flag.
-		for i2c.Bus.SR1&stm32.I2C_SR1_ADDR == 0 {
+		for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_ADDR) {
 			timeout--
 			if timeout == 0 {
 				return errors.New("I2C timeout on send write address")
@@ -716,7 +721,7 @@ func (i2c I2C) sendAddress(address uint8, write bool) error {
 		}
 
 		timeout = i2cTimeout
-		for i2c.Bus.SR2&(stm32.I2C_SR2_MSL|stm32.I2C_SR2_BUSY|stm32.I2C_SR2_TRA) == 0 {
+		for !i2c.Bus.SR2.HasBits(stm32.I2C_SR2_MSL | stm32.I2C_SR2_BUSY | stm32.I2C_SR2_TRA) {
 			timeout--
 			if timeout == 0 {
 				return errors.New("I2C timeout on send write address")
@@ -724,7 +729,7 @@ func (i2c I2C) sendAddress(address uint8, write bool) error {
 		}
 	} else {
 		// I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED which is ADDR flag.
-		for (i2c.Bus.SR1 & stm32.I2C_SR1_ADDR) == 0 {
+		for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_ADDR) {
 			timeout--
 			if timeout == 0 {
 				return errors.New("I2C timeout on send read address")
@@ -738,13 +743,13 @@ func (i2c I2C) sendAddress(address uint8, write bool) error {
 // WriteByte writes a single byte to the I2C bus.
 func (i2c I2C) WriteByte(data byte) error {
 	// Send data byte
-	i2c.Bus.DR = stm32.RegValue(data)
+	i2c.Bus.DR.Set(uint32(data))
 
 	// Wait for I2C EV8_2 when data has been physically shifted out and
 	// output on the bus.
 	// I2C_EVENT_MASTER_BYTE_TRANSMITTED is TXE flag.
 	timeout := i2cTimeout
-	for i2c.Bus.SR1&stm32.I2C_SR1_TxE == 0 {
+	for !i2c.Bus.SR1.HasBits(stm32.I2C_SR1_TxE) {
 		timeout--
 		if timeout == 0 {
 			return errors.New("I2C timeout on write")

src/machine/machine_stm32f407.go

@@ -13,15 +13,15 @@ const CPU_FREQUENCY = 168000000
 
 const (
 	// Mode Flag
-	GPIO_OUTPUT         = 0
-	GPIO_INPUT          = GPIO_INPUT_PULLDOWN
-	GPIO_INPUT_FLOATING = 1
-	GPIO_INPUT_PULLDOWN = 2
-	GPIO_INPUT_PULLUP   = 3
+	PinOutput        PinMode = 0
+	PinInput         PinMode = PinInputFloating
+	PinInputFloating PinMode = 1
+	PinInputPulldown PinMode = 2
+	PinInputPullup   PinMode = 3
 
 	// for UART
-	GPIO_UART_TX = 4
-	GPIO_UART_RX = 5
+	PinModeUartTX PinMode = 4
+	PinModeUartRX PinMode = 5
 
 	//GPIOx_MODER
 	GPIO_MODE_INPUT          = 0
@@ -45,8 +45,8 @@ const (
 	GPIO_PULL_DOWN = 2
 )
 
-func (p GPIO) getPort() *stm32.GPIO_Type {
-	switch p.Pin / 16 {
+func (p Pin) getPort() *stm32.GPIO_Type {
+	switch p / 16 {
 	case 0:
 		return stm32.GPIOA
 	case 1:
@@ -71,83 +71,83 @@ func (p GPIO) getPort() *stm32.GPIO_Type {
 }
 
 // enableClock enables the clock for this desired GPIO port.
-func (p GPIO) enableClock() {
-	switch p.Pin / 16 {
+func (p Pin) enableClock() {
+	switch p / 16 {
 	case 0:
-		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOAEN
+		stm32.RCC.AHB1ENR.SetBits(stm32.RCC_AHB1ENR_GPIOAEN)
 	case 1:
-		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOBEN
+		stm32.RCC.AHB1ENR.SetBits(stm32.RCC_AHB1ENR_GPIOBEN)
 	case 2:
-		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOCEN
+		stm32.RCC.AHB1ENR.SetBits(stm32.RCC_AHB1ENR_GPIOCEN)
 	case 3:
-		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIODEN
+		stm32.RCC.AHB1ENR.SetBits(stm32.RCC_AHB1ENR_GPIODEN)
 	case 4:
-		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOEEN
+		stm32.RCC.AHB1ENR.SetBits(stm32.RCC_AHB1ENR_GPIOEEN)
 	case 5:
-		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOFEN
+		stm32.RCC.AHB1ENR.SetBits(stm32.RCC_AHB1ENR_GPIOFEN)
 	case 6:
-		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOGEN
+		stm32.RCC.AHB1ENR.SetBits(stm32.RCC_AHB1ENR_GPIOGEN)
 	case 7:
-		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOHEN
+		stm32.RCC.AHB1ENR.SetBits(stm32.RCC_AHB1ENR_GPIOHEN)
 	case 8:
-		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOIEN
+		stm32.RCC.AHB1ENR.SetBits(stm32.RCC_AHB1ENR_GPIOIEN)
 	default:
 		panic("machine: unknown port")
 	}
 }
 
 // Configure this pin with the given configuration.
-func (p GPIO) Configure(config GPIOConfig) {
+func (p Pin) Configure(config PinConfig) {
 	// Configure the GPIO pin.
 	p.enableClock()
 	port := p.getPort()
-	pin := p.Pin % 16
+	pin := uint8(p) % 16
 	pos := pin * 2
 
-	if config.Mode == GPIO_INPUT_FLOATING {
-		port.MODER = stm32.RegValue((uint32(port.MODER)&^(0x3<<pos) | (uint32(GPIO_MODE_INPUT) << pos)))
-		port.PUPDR = stm32.RegValue((uint32(port.PUPDR)&^(0x3<<pos) | (uint32(GPIO_FLOATING) << pos)))
-	} else if config.Mode == GPIO_INPUT_PULLDOWN {
-		port.MODER = stm32.RegValue((uint32(port.MODER)&^(0x3<<pos) | (uint32(GPIO_MODE_INPUT) << pos)))
-		port.PUPDR = stm32.RegValue((uint32(port.PUPDR)&^(0x3<<pos) | (uint32(GPIO_PULL_DOWN) << pos)))
-	} else if config.Mode == GPIO_INPUT_PULLUP {
-		port.MODER = stm32.RegValue((uint32(port.MODER)&^(0x3<<pos) | (uint32(GPIO_MODE_INPUT) << pos)))
-		port.PUPDR = stm32.RegValue((uint32(port.PUPDR)&^(0x3<<pos) | (uint32(GPIO_PULL_UP) << pos)))
-	} else if config.Mode == GPIO_OUTPUT {
-		port.MODER = stm32.RegValue((uint32(port.MODER)&^(0x3<<pos) | (uint32(GPIO_MODE_GENERAL_OUTPUT) << pos)))
-		port.OSPEEDR = stm32.RegValue((uint32(port.OSPEEDR)&^(0x3<<pos) | (uint32(GPIO_SPEED_HI) << pos)))
-	} else if config.Mode == GPIO_UART_TX {
-		port.MODER = stm32.RegValue((uint32(port.MODER)&^(0x3<<pos) | (uint32(GPIO_MODE_ALTERNABTIVE) << pos)))
-		port.OSPEEDR = stm32.RegValue((uint32(port.OSPEEDR)&^(0x3<<pos) | (uint32(GPIO_SPEED_HI) << pos)))
-		port.PUPDR = stm32.RegValue((uint32(port.PUPDR)&^(0x3<<pos) | (uint32(GPIO_PULL_UP) << pos)))
+	if config.Mode == PinInputFloating {
+		port.MODER.Set((uint32(port.MODER.Get())&^(0x3<<pos) | (uint32(GPIO_MODE_INPUT) << pos)))
+		port.PUPDR.Set((uint32(port.PUPDR.Get())&^(0x3<<pos) | (uint32(GPIO_FLOATING) << pos)))
+	} else if config.Mode == PinInputPulldown {
+		port.MODER.Set((uint32(port.MODER.Get())&^(0x3<<pos) | (uint32(GPIO_MODE_INPUT) << pos)))
+		port.PUPDR.Set((uint32(port.PUPDR.Get())&^(0x3<<pos) | (uint32(GPIO_PULL_DOWN) << pos)))
+	} else if config.Mode == PinInputPullup {
+		port.MODER.Set((uint32(port.MODER.Get())&^(0x3<<pos) | (uint32(GPIO_MODE_INPUT) << pos)))
+		port.PUPDR.Set((uint32(port.PUPDR.Get())&^(0x3<<pos) | (uint32(GPIO_PULL_UP) << pos)))
+	} else if config.Mode == PinOutput {
+		port.MODER.Set((uint32(port.MODER.Get())&^(0x3<<pos) | (uint32(GPIO_MODE_GENERAL_OUTPUT) << pos)))
+		port.OSPEEDR.Set((uint32(port.OSPEEDR.Get())&^(0x3<<pos) | (uint32(GPIO_SPEED_HI) << pos)))
+	} else if config.Mode == PinModeUartTX {
+		port.MODER.Set((uint32(port.MODER.Get())&^(0x3<<pos) | (uint32(GPIO_MODE_ALTERNABTIVE) << pos)))
+		port.OSPEEDR.Set((uint32(port.OSPEEDR.Get())&^(0x3<<pos) | (uint32(GPIO_SPEED_HI) << pos)))
+		port.PUPDR.Set((uint32(port.PUPDR.Get())&^(0x3<<pos) | (uint32(GPIO_PULL_UP) << pos)))
 		p.setAltFunc(0x7)
-	} else if config.Mode == GPIO_UART_RX {
-		port.MODER = stm32.RegValue((uint32(port.MODER)&^(0x3<<pos) | (uint32(GPIO_MODE_ALTERNABTIVE) << pos)))
-		port.PUPDR = stm32.RegValue((uint32(port.PUPDR)&^(0x3<<pos) | (uint32(GPIO_FLOATING) << pos)))
+	} else if config.Mode == PinModeUartRX {
+		port.MODER.Set((uint32(port.MODER.Get())&^(0x3<<pos) | (uint32(GPIO_MODE_ALTERNABTIVE) << pos)))
+		port.PUPDR.Set((uint32(port.PUPDR.Get())&^(0x3<<pos) | (uint32(GPIO_FLOATING) << pos)))
 		p.setAltFunc(0x7)
 	}
 }
 
-func (p GPIO) setAltFunc(af uint32) {
+func (p Pin) setAltFunc(af uint32) {
 	port := p.getPort()
-	pin := p.Pin % 16
+	pin := uint8(p) % 16
 	pos := pin * 4
 	if pin >= 8 {
-		port.AFRH = stm32.RegValue(uint32(port.AFRH)&^(0xF<<pos) | ((af & 0xF) << pos))
+		port.AFRH.Set(uint32(port.AFRH.Get())&^(0xF<<pos) | ((af & 0xF) << pos))
 	} else {
-		port.AFRL = stm32.RegValue(uint32(port.AFRL)&^(0xF<<pos) | ((af & 0xF) << pos))
+		port.AFRL.Set(uint32(port.AFRL.Get())&^(0xF<<pos) | ((af & 0xF) << pos))
 	}
 }
 
 // Set the pin to high or low.
 // Warning: only use this on an output pin!
-func (p GPIO) Set(high bool) {
+func (p Pin) Set(high bool) {
 	port := p.getPort()
-	pin := p.Pin % 16
+	pin := p % 16
 	if high {
-		port.BSRR = 1 << pin
+		port.BSRR.Set(1 << uint8(pin))
 	} else {
-		port.BSRR = 1 << (pin + 16)
+		port.BSRR.Set(1 << uint8(pin+16))
 	}
 }
 
@@ -173,12 +173,12 @@ func (uart UART) Configure(config UARTConfig) {
 	switch config.TX {
 	default:
 		// use standard TX/RX pins PA2 and PA3
-		GPIO{UART_TX_PIN}.Configure(GPIOConfig{Mode: GPIO_UART_TX})
-		GPIO{UART_RX_PIN}.Configure(GPIOConfig{Mode: GPIO_UART_RX})
+		UART_TX_PIN.Configure(PinConfig{Mode: PinModeUartTX})
+		UART_RX_PIN.Configure(PinConfig{Mode: PinModeUartRX})
 	}
 
 	// Enable USART2 clock
-	stm32.RCC.APB1ENR |= stm32.RCC_APB1ENR_USART2EN
+	stm32.RCC.APB1ENR.SetBits(stm32.RCC_APB1ENR_USART2EN)
 
 	/*
 	  Set baud rate(115200)
@@ -195,10 +195,10 @@ func (uart UART) Configure(config UARTConfig) {
 	  | 115200   | 0x16D  |
 	  +----------+--------+
 	*/
-	stm32.USART2.BRR = 0x16c
+	stm32.USART2.BRR.Set(0x16c)
 
 	// Enable USART2 port.
-	stm32.USART2.CR1 = stm32.USART_CR1_TE | stm32.USART_CR1_RE | stm32.USART_CR1_RXNEIE | stm32.USART_CR1_UE
+	stm32.USART2.CR1.Set(stm32.USART_CR1_TE | stm32.USART_CR1_RE | stm32.USART_CR1_RXNEIE | stm32.USART_CR1_UE)
 
 	// Enable RX IRQ.
 	arm.SetPriority(stm32.IRQ_USART2, 0xc0)
@@ -207,14 +207,14 @@ func (uart UART) Configure(config UARTConfig) {
 
 // WriteByte writes a byte of data to the UART.
 func (uart UART) WriteByte(c byte) error {
-	stm32.USART2.DR = stm32.RegValue(c)
+	stm32.USART2.DR.Set(uint32(c))
 
-	for (stm32.USART2.SR & stm32.USART_SR_TXE) == 0 {
+	for !stm32.USART2.SR.HasBits(stm32.USART_SR_TXE) {
 	}
 	return nil
 }
 
 //go:export USART2_IRQHandler
 func handleUSART2() {
-	UART1.Receive(byte((stm32.USART2.DR & 0xFF)))
+	UART1.Receive(byte((stm32.USART2.DR.Get() & 0xFF)))
 }

src/machine/uart.go

@@ -6,8 +6,8 @@ import "errors"
 
 type UARTConfig struct {
 	BaudRate uint32
-	TX       uint8
-	RX       uint8
+	TX       Pin
+	RX       Pin
 }
 
 // To implement the UART interface for a board, you must declare a concrete type as follows:

src/machine/usb.go

@@ -484,11 +484,11 @@ const (
 // 		 RoReg8                    Reserved1[0x5];
 //   } UsbDeviceDescBank;
 type usbDeviceDescBank struct {
-	ADDR      sam.RegValue
-	PCKSIZE   sam.RegValue
-	EXTREG    sam.RegValue16
-	STATUS_BK sam.RegValue8
-	_reserved [5]sam.RegValue8
+	ADDR      sam.Register32
+	PCKSIZE   sam.Register32
+	EXTREG    sam.Register16
+	STATUS_BK sam.Register8
+	_reserved [5]sam.Register8
 }
 
 type usbDeviceDescriptor struct {

src/runtime/chan.go

@@ -39,33 +39,27 @@ const (
 	chanStateClosed
 )
 
-func chanSendStub(caller *coroutine, ch *channel, _ unsafe.Pointer, size uintptr)
-func chanRecvStub(caller *coroutine, ch *channel, _ unsafe.Pointer, _ *bool, size uintptr)
 func deadlockStub()
 
 // chanSend sends a single value over the channel. If this operation can
 // complete immediately (there is a goroutine waiting for a value), it sends the
 // value and re-activates both goroutines. If not, it sets itself as waiting on
 // a value.
-//
-// The unsafe.Pointer value is used during lowering. During IR generation, it
-// points to the to-be-received value. During coroutine lowering, this value is
-// replaced with a read from the coroutine promise.
-func chanSend(sender *coroutine, ch *channel, _ unsafe.Pointer, size uintptr) {
+func chanSend(sender *coroutine, ch *channel, value unsafe.Pointer, size uintptr) {
 	if ch == nil {
 		// A nil channel blocks forever. Do not scheduler this goroutine again.
 		return
 	}
 	switch ch.state {
 	case chanStateEmpty:
+		sender.promise().ptr = value
 		ch.state = chanStateSend
 		ch.blocked = sender
 	case chanStateRecv:
 		receiver := ch.blocked
 		receiverPromise := receiver.promise()
-		senderPromise := sender.promise()
-		memcpy(unsafe.Pointer(&receiverPromise.data), unsafe.Pointer(&senderPromise.data), size)
-		receiverPromise.commaOk = true
+		memcpy(receiverPromise.ptr, value, size)
+		receiverPromise.data = 1 // commaOk = true
 		ch.blocked = receiverPromise.next
 		receiverPromise.next = nil
 		activateTask(receiver)
@@ -76,6 +70,7 @@ func chanSend(sender *coroutine, ch *channel, _ unsafe.Pointer, size uintptr) {
 	case chanStateClosed:
 		runtimePanic("send on closed channel")
 	case chanStateSend:
+		sender.promise().ptr = value
 		sender.promise().next = ch.blocked
 		ch.blocked = sender
 	}
@@ -85,11 +80,7 @@ func chanSend(sender *coroutine, ch *channel, _ unsafe.Pointer, size uintptr) {
 // sender, it receives the value immediately and re-activates both coroutines.
 // If not, it sets itself as available for receiving. If the channel is closed,
 // it immediately activates itself with a zero value as the result.
-//
-// The two unnamed values exist to help during lowering. The unsafe.Pointer
-// points to the value, and the *bool points to the comma-ok value. Both are
-// replaced by reads from the coroutine promise.
-func chanRecv(receiver *coroutine, ch *channel, _ unsafe.Pointer, _ *bool, size uintptr) {
+func chanRecv(receiver *coroutine, ch *channel, value unsafe.Pointer, size uintptr) {
 	if ch == nil {
 		// A nil channel blocks forever. Do not scheduler this goroutine again.
 		return
@@ -97,10 +88,9 @@ func chanRecv(receiver *coroutine, ch *channel, _ unsafe.Pointer, _ *bool, size
 	switch ch.state {
 	case chanStateSend:
 		sender := ch.blocked
-		receiverPromise := receiver.promise()
 		senderPromise := sender.promise()
-		memcpy(unsafe.Pointer(&receiverPromise.data), unsafe.Pointer(&senderPromise.data), size)
-		receiverPromise.commaOk = true
+		memcpy(value, senderPromise.ptr, size)
+		receiver.promise().data = 1 // commaOk = true
 		ch.blocked = senderPromise.next
 		senderPromise.next = nil
 		activateTask(receiver)
@@ -109,14 +99,15 @@ func chanRecv(receiver *coroutine, ch *channel, _ unsafe.Pointer, _ *bool, size
 			ch.state = chanStateEmpty
 		}
 	case chanStateEmpty:
+		receiver.promise().ptr = value
 		ch.state = chanStateRecv
 		ch.blocked = receiver
 	case chanStateClosed:
-		receiverPromise := receiver.promise()
-		memzero(unsafe.Pointer(&receiverPromise.data), size)
-		receiverPromise.commaOk = false
+		memzero(value, size)
+		receiver.promise().data = 0 // commaOk = false
 		activateTask(receiver)
 	case chanStateRecv:
+		receiver.promise().ptr = value
 		receiver.promise().next = ch.blocked
 		ch.blocked = receiver
 	}
@@ -142,8 +133,8 @@ func chanClose(ch *channel, size uintptr) {
 	case chanStateRecv:
 		// The receiver must be re-activated with a zero value.
 		receiverPromise := ch.blocked.promise()
-		memzero(unsafe.Pointer(&receiverPromise.data), size)
-		receiverPromise.commaOk = false
+		memzero(receiverPromise.ptr, size)
+		receiverPromise.data = 0 // commaOk = false
 		activateTask(ch.blocked)
 		ch.state = chanStateClosed
 		ch.blocked = nil

src/runtime/complex.go

@@ -0,0 +1,65 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+// inf2one returns a signed 1 if f is an infinity and a signed 0 otherwise.
+// The sign of the result is the sign of f.
+func inf2one(f float64) float64 {
+	g := 0.0
+	if isInf(f) {
+		g = 1.0
+	}
+	return copysign(g, f)
+}
+
+func complex64div(n complex64, m complex64) complex64 {
+	return complex64(complex128div(complex128(n), complex128(m)))
+}
+
+func complex128div(n complex128, m complex128) complex128 {
+	var e, f float64 // complex(e, f) = n/m
+
+	// Algorithm for robust complex division as described in
+	// Robert L. Smith: Algorithm 116: Complex division. Commun. ACM 5(8): 435 (1962).
+	if abs(real(m)) >= abs(imag(m)) {
+		ratio := imag(m) / real(m)
+		denom := real(m) + ratio*imag(m)
+		e = (real(n) + imag(n)*ratio) / denom
+		f = (imag(n) - real(n)*ratio) / denom
+	} else {
+		ratio := real(m) / imag(m)
+		denom := imag(m) + ratio*real(m)
+		e = (real(n)*ratio + imag(n)) / denom
+		f = (imag(n)*ratio - real(n)) / denom
+	}
+
+	if isNaN(e) && isNaN(f) {
+		// Correct final result to infinities and zeros if applicable.
+		// Matches C99: ISO/IEC 9899:1999 - G.5.1  Multiplicative operators.
+
+		a, b := real(n), imag(n)
+		c, d := real(m), imag(m)
+
+		switch {
+		case m == 0 && (!isNaN(a) || !isNaN(b)):
+			e = copysign(inf, c) * a
+			f = copysign(inf, c) * b
+
+		case (isInf(a) || isInf(b)) && isFinite(c) && isFinite(d):
+			a = inf2one(a)
+			b = inf2one(b)
+			e = inf * (a*c + b*d)
+			f = inf * (b*c - a*d)
+
+		case (isInf(c) || isInf(d)) && isFinite(a) && isFinite(b):
+			c = inf2one(c)
+			d = inf2one(d)
+			e = 0 * (a*c + b*d)
+			f = 0 * (b*c - a*d)
+		}
+	}
+
+	return complex(e, f)
+}

src/runtime/float.go

@@ -0,0 +1,53 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import "unsafe"
+
+var inf = float64frombits(0x7FF0000000000000)
+
+// isNaN reports whether f is an IEEE 754 ``not-a-number'' value.
+func isNaN(f float64) (is bool) {
+	// IEEE 754 says that only NaNs satisfy f != f.
+	return f != f
+}
+
+// isFinite reports whether f is neither NaN nor an infinity.
+func isFinite(f float64) bool {
+	return !isNaN(f - f)
+}
+
+// isInf reports whether f is an infinity.
+func isInf(f float64) bool {
+	return !isNaN(f) && !isFinite(f)
+}
+
+// Abs returns the absolute value of x.
+//
+// Special cases are:
+//	Abs(±Inf) = +Inf
+//	Abs(NaN) = NaN
+func abs(x float64) float64 {
+	const sign = 1 << 63
+	return float64frombits(float64bits(x) &^ sign)
+}
+
+// copysign returns a value with the magnitude
+// of x and the sign of y.
+func copysign(x, y float64) float64 {
+	const sign = 1 << 63
+	return float64frombits(float64bits(x)&^sign | float64bits(y)&sign)
+}
+
+// Float64bits returns the IEEE 754 binary representation of f.
+func float64bits(f float64) uint64 {
+	return *(*uint64)(unsafe.Pointer(&f))
+}
+
+// Float64frombits returns the floating point number corresponding
+// the IEEE 754 binary representation b.
+func float64frombits(b uint64) float64 {
+	return *(*float64)(unsafe.Pointer(&b))
+}

src/runtime/hashmap.go

@@ -60,14 +60,20 @@ func hashmapTopHash(hash uint32) uint8 {
 }
 
 // Create a new hashmap with the given keySize and valueSize.
-func hashmapMake(keySize, valueSize uint8) *hashmap {
+func hashmapMake(keySize, valueSize uint8, sizeHint uintptr) *hashmap {
+	numBuckets := sizeHint / 8
+	bucketBits := uint8(0)
+	for numBuckets != 0 {
+		numBuckets /= 2
+		bucketBits++
+	}
 	bucketBufSize := unsafe.Sizeof(hashmapBucket{}) + uintptr(keySize)*8 + uintptr(valueSize)*8
-	bucket := alloc(bucketBufSize)
+	buckets := alloc(bucketBufSize * (1 << bucketBits))
 	return &hashmap{
-		buckets:    bucket,
+		buckets:    buckets,
 		keySize:    keySize,
 		valueSize:  valueSize,
-		bucketBits: 0,
+		bucketBits: bucketBits,
 	}
 }
 
@@ -83,13 +89,20 @@ func hashmapLen(m *hashmap) int {
 // Set a specified key to a given value. Grow the map if necessary.
 //go:nobounds
 func hashmapSet(m *hashmap, key unsafe.Pointer, value unsafe.Pointer, hash uint32, keyEqual func(x, y unsafe.Pointer, n uintptr) bool) {
+	tophash := hashmapTopHash(hash)
+
+	if m.buckets == nil {
+		// No bucket was allocated yet, do so now.
+		m.buckets = unsafe.Pointer(hashmapInsertIntoNewBucket(m, key, value, tophash))
+		return
+	}
+
 	numBuckets := uintptr(1) << m.bucketBits
 	bucketNumber := (uintptr(hash) & (numBuckets - 1))
 	bucketSize := unsafe.Sizeof(hashmapBucket{}) + uintptr(m.keySize)*8 + uintptr(m.valueSize)*8
 	bucketAddr := uintptr(m.buckets) + bucketSize*bucketNumber
 	bucket := (*hashmapBucket)(unsafe.Pointer(bucketAddr))
-
-	tophash := hashmapTopHash(hash)
+	var lastBucket *hashmapBucket
 
 	// See whether the key already exists somewhere.
 	var emptySlotKey unsafe.Pointer
@@ -98,9 +111,9 @@ func hashmapSet(m *hashmap, key unsafe.Pointer, value unsafe.Pointer, hash uint3
 	for bucket != nil {
 		for i := uintptr(0); i < 8; i++ {
 			slotKeyOffset := unsafe.Sizeof(hashmapBucket{}) + uintptr(m.keySize)*uintptr(i)
-			slotKey := unsafe.Pointer(bucketAddr + slotKeyOffset)
+			slotKey := unsafe.Pointer(uintptr(unsafe.Pointer(bucket)) + slotKeyOffset)
 			slotValueOffset := unsafe.Sizeof(hashmapBucket{}) + uintptr(m.keySize)*8 + uintptr(m.valueSize)*uintptr(i)
-			slotValue := unsafe.Pointer(bucketAddr + slotValueOffset)
+			slotValue := unsafe.Pointer(uintptr(unsafe.Pointer(bucket)) + slotValueOffset)
 			if bucket.tophash[i] == 0 && emptySlotKey == nil {
 				// Found an empty slot, store it for if we couldn't find an
 				// existing slot.
@@ -109,7 +122,7 @@ func hashmapSet(m *hashmap, key unsafe.Pointer, value unsafe.Pointer, hash uint3
 				emptySlotTophash = &bucket.tophash[i]
 			}
 			if bucket.tophash[i] == tophash {
-				// Could be an existing value that's the same.
+				// Could be an existing key that's the same.
 				if keyEqual(key, slotKey, uintptr(m.keySize)) {
 					// found same key, replace it
 					memcpy(slotValue, value, uintptr(m.valueSize))
@@ -117,16 +130,37 @@ func hashmapSet(m *hashmap, key unsafe.Pointer, value unsafe.Pointer, hash uint3
 				}
 			}
 		}
+		lastBucket = bucket
 		bucket = bucket.next
 	}
-	if emptySlotKey != nil {
-		m.count++
-		memcpy(emptySlotKey, key, uintptr(m.keySize))
-		memcpy(emptySlotValue, value, uintptr(m.valueSize))
-		*emptySlotTophash = tophash
+	if emptySlotKey == nil {
+		// Add a new bucket to the bucket chain.
+		// TODO: rebalance if necessary to avoid O(n) insert and lookup time.
+		lastBucket.next = (*hashmapBucket)(hashmapInsertIntoNewBucket(m, key, value, tophash))
 		return
 	}
-	panic("todo: hashmap: grow bucket")
+	m.count++
+	memcpy(emptySlotKey, key, uintptr(m.keySize))
+	memcpy(emptySlotValue, value, uintptr(m.valueSize))
+	*emptySlotTophash = tophash
+}
+
+// hashmapInsertIntoNewBucket creates a new bucket, inserts the given key and
+// value into the bucket, and returns a pointer to this bucket.
+func hashmapInsertIntoNewBucket(m *hashmap, key, value unsafe.Pointer, tophash uint8) *hashmapBucket {
+	bucketBufSize := unsafe.Sizeof(hashmapBucket{}) + uintptr(m.keySize)*8 + uintptr(m.valueSize)*8
+	bucketBuf := alloc(bucketBufSize)
+	// Insert into the first slot, which is empty as it has just been allocated.
+	slotKeyOffset := unsafe.Sizeof(hashmapBucket{})
+	slotKey := unsafe.Pointer(uintptr(bucketBuf) + slotKeyOffset)
+	slotValueOffset := unsafe.Sizeof(hashmapBucket{}) + uintptr(m.keySize)*8
+	slotValue := unsafe.Pointer(uintptr(bucketBuf) + slotValueOffset)
+	m.count++
+	memcpy(slotKey, key, uintptr(m.keySize))
+	memcpy(slotValue, value, uintptr(m.valueSize))
+	bucket := (*hashmapBucket)(bucketBuf)
+	bucket.tophash[0] = tophash
+	return bucket
 }
 
 // Get the value of a specified key, or zero the value if not found.