machine/dummy: add hooks to override peripheral methods

These two dependencies are optional but enabled by default when
available. Disable them in the Makefile so that the tinygo binary is
portable to systems that don't have them or have a different version
(for example, Arch has a newer version of libcurses and thus libtinfo).

.circleci/config.yml

@@ -18,14 +18,12 @@ commands:
             wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
             sudo apt-get update
             sudo apt-get install \
-                llvm \
                 python3 \
                 llvm<<parameters.llvm>>-dev \
                 clang<<parameters.llvm>> \
                 libclang<<parameters.llvm>>-dev \
                 lld<<parameters.llvm>> \
                 gcc-arm-linux-gnueabihf \
-                binutils-arm-none-eabi \
                 libc6-dev-armel-cross \
                 gcc-aarch64-linux-gnu \
                 libc6-dev-arm64-cross \
@@ -49,45 +47,61 @@ commands:
           command: |
             curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
             dep ensure --vendor-only
+  llvm-source-linux:
+    steps:
+      - 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
   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
+  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 -size short -o blinky2                              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=arduino             examples/blinky1
-      - run: tinygo build -size short -o test.elf -target=digispark           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
-
-
-jobs:
-  test-llvm7-go111:
-    docker:
-      - image: circleci/golang:1.11
-
-    working_directory: /go/src/github.com/tinygo-org/tinygo
+      - 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
+  test-linux:
+    parameters:
+      llvm:
+        type: string
     steps:
       - checkout
       - submodules
       - apt-dependencies:
-          llvm: "-7"
+          llvm: <<parameters.llvm>>
       - install-node
       - restore_cache:
           keys:
             - go-cache-{{ checksum "Gopkg.lock" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
             - go-cache-{{ checksum "Gopkg.lock" }}
+      - llvm-source-linux
       - dep
       - run: go install .
-      - run: make test
+      - run: go test -v
       - run: make gen-device -j4
       - smoketest
       - save_cache:
@@ -95,8 +109,181 @@ jobs:
           paths:
             - ~/.cache/go-build
             - ~/.cache/tinygo
+      - run: make fmt-check
+  build-linux:
+    steps:
+      - checkout
+      - submodules
+      - run:
+          name: "Install apt dependencies"
+          command: |
+            sudo apt-get install \
+                python3 \
+                gcc-arm-linux-gnueabihf \
+                binutils-arm-none-eabi \
+                libc6-dev-armel-cross \
+                gcc-aarch64-linux-gnu \
+                libc6-dev-arm64-cross \
+                qemu-system-arm \
+                qemu-user \
+                gcc-avr \
+                avr-libc
+      - install-node
+      - restore_cache:
+          keys:
+            - go-cache-{{ checksum "Gopkg.lock" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-{{ checksum "Gopkg.lock" }}
+      - llvm-source-linux
+      - restore_cache:
+          keys:
+            - llvm-build-8-linux-v4
+      - run:
+          name: "Build LLVM"
+          command: |
+            if [ ! -f llvm-build/lib/liblldELF.a ]
+            then
+              # install dependencies
+              sudo apt-get install cmake clang ninja-build
+              # make build faster
+              export CC=clang
+              export CXX=clang++
+              # hack ninja to use less jobs
+              echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
+              chmod +x /go/bin/ninja
+              # build!
+              make llvm-build
+            fi
+      - save_cache:
+          key: llvm-build-8-linux-v4
+          paths:
+            llvm-build
+      - run:
+          name: "Create LLVM symlinks"
+          command: |
+            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
+      - run:
+          name: "Build TinyGo release"
+          command: |
+            make release -j3
+            cp -p build/release.tar.gz /tmp/tinygo.linux-amd64.tar.gz
+      - store_artifacts:
+          path: /tmp/tinygo.linux-amd64.tar.gz
+      - save_cache:
+          key: go-cache-{{ checksum "Gopkg.lock" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - ~/.cache/tinygo
+      - run:
+          name: "Extract release tarball"
+          command: |
+            mkdir -p ~/lib
+            tar -C ~/lib -xf /tmp/tinygo.linux-amd64.tar.gz
+            ln -s ~/lib/tinygo/bin/tinygo /go/bin/tinygo
+            tinygo version
+      - smoketest
+  build-macos:
+    steps:
+      - checkout
+      - submodules
+      - run:
+          name: "Install dependencies"
+          command: |
+            HOMEBREW_NO_AUTO_UPDATE=1 brew install go dep qemu
+      - restore_cache:
+          keys:
+            - llvm-source-8-macos-v2
+      - run:
+          name: "Fetch LLVM source"
+          command: make llvm-source
+      - save_cache:
+          key: llvm-source-8-macos-v2
+          paths:
+            - llvm
+      - restore_cache:
+          keys:
+            - llvm-build-8-macos-v3
+      - run:
+          name: "Build LLVM"
+          command: |
+            if [ ! -f llvm-build/lib/liblldELF.a ]
+            then
+              # install dependencies
+              HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake ninja
+              # build!
+              make llvm-build
+            fi
+      - save_cache:
+          key: llvm-build-8-macos-v3
+          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
+      - run:
+          name: "Build TinyGo release"
+          command: |
+            make release -j3
+            cp -p build/release.tar.gz /tmp/tinygo.darwin-amd64.tar.gz
+      - store_artifacts:
+          path: /tmp/tinygo.darwin-amd64.tar.gz
+      - run:
+          name: "Extract release tarball"
+          command: |
+            mkdir -p ~/lib
+            tar -C /usr/local/opt -xf /tmp/tinygo.darwin-amd64.tar.gz
+            ln -s /usr/local/opt/tinygo/bin/tinygo /usr/local/bin/tinygo
+            tinygo version
+      - smoketest-no-avr
+
+
+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-llvm8-go112:
+    docker:
+      - image: circleci/golang:1.12
+    working_directory: /go/src/github.com/tinygo-org/tinygo
+    steps:
+      - test-linux:
+          llvm: "-8"
+  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
+
+
+
 
 workflows:
   test-all:
     jobs:
-      - test-llvm7-go111
+      - test-llvm8-go111
+      - test-llvm8-go112
+      - build-linux
+      - build-macos

.gitignore

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

.gitmodules

@@ -13,4 +13,4 @@
 [submodule "lib/compiler-rt"]
 	path = lib/compiler-rt
 	url = https://github.com/llvm-mirror/compiler-rt.git
-	branch = release_70
+	branch = release_80

.travis.yml

@@ -1,40 +0,0 @@
-language: go
-
-matrix:
-  include:
-  - os: osx
-    go: "1.11"
-    env: PATH="/usr/local/opt/llvm/bin:$PATH"
-    before_install:
-    - mkdir -p /Users/travis/gopath/bin
-
-addons:
-  homebrew:
-    update: true
-    taps: ArmMbed/homebrew-formulae
-    packages:
-    - llvm@7
-    - qemu
-    - arm-none-eabi-gcc
-
-install:
-  - curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
-  - dep ensure --vendor-only
-
-script:
-  - go install github.com/tinygo-org/tinygo
-  - go test -v .
-  - make gen-device
-  - tinygo build -size short -o blinky1.nrf.elf    -target=pca10040     examples/blinky1
-  - tinygo build -size short -o blinky2.nrf.elf    -target=pca10040     examples/blinky2
-  - tinygo build             -o blinky2                                 examples/blinky2 # TODO: re-enable -size flag with MachO support
-  - tinygo build -size short -o test.nrf.elf       -target=pca10040     examples/test
-  - tinygo build -size short -o blinky1.nrf51.elf  -target=microbit     examples/echo
-  - tinygo build -size short -o test.nrf.elf       -target=nrf52840-mdk examples/blinky1
-  - tinygo build -size short -o blinky1.nrf51d.elf -target=pca10031     examples/blinky1
-  - tinygo build -size short -o blinky1.stm32.elf  -target=bluepill     examples/blinky1
-  - tinygo build -size short -o blinky1.reel.elf   -target=reelboard    examples/blinky1
-  - tinygo build -size short -o blinky2.reel.elf   -target=reelboard    examples/blinky2
-  - tinygo build -size short -o blinky1.pca10056.elf    -target=pca10056     examples/blinky1
-  - tinygo build -size short -o blinky2.pca10056.elf    -target=pca10056     examples/blinky2
-  - tinygo build -size short -o blinky1.samd21.elf    -target=itsybitsy-m0     examples/blinky1

BUILDING.md

@@ -2,9 +2,9 @@
 
 TinyGo depends on LLVM and libclang, which are both big C++ libraries. It can
 also optionally use a built-in lld to ease cross compiling. There are two ways
-these can be linked: dynamically and statically. The default is dynamic linking
-because it is fast and works almost out of the box on Debian-based systems with
-the right libraries installed.
+these can be linked: dynamically and statically. An install with `go install` is
+dynamic linking because it is fast and works almost out of the box on
+Debian-based systems with the right packages installed.
 
 This guide describes how to statically link TinyGo against LLVM, libclang and
 lld so that the binary can be easily moved between systems. It also shows how to
@@ -18,81 +18,49 @@ build tools to be built. Go is of course necessary to build TinyGo itself.
   * Go (1.11+)
   * [dep](https://golang.github.io/dep/)
   * Standard build tools (gcc/clang)
-  * git or subversion
+  * git
   * CMake
-  * [Ninja](https://ninja-build.org/) or make (preferably Ninja)
+  * [Ninja](https://ninja-build.org/)
 
 The rest of this guide assumes you're running Linux, but it should be equivalent
 on a different system like Mac.
 
 ## Download the source
 
-The first step is to get the source code. Place it in some directory, assuming
-`$HOME/src` here, but you can pick a different one of course:
+The first step is to download the TinyGo sources. Then, inside the directory,
+perform these steps:
 
-    git clone -b release_70 https://github.com/llvm-mirror/llvm.git $HOME/src/llvm
-    git clone -b release_70 https://github.com/llvm-mirror/clang.git $HOME/src/llvm/tools/clang
-    git clone -b release_70 https://github.com/llvm-mirror/lld.git $HOME/src/llvm/tools/lld
-    go get -d github.com/tinygo-org/tinygo
-    cd $HOME/go/src/github.com/tinygo-org/tinygo
-    dep ensure -vendor-only # download dependencies
+    dep ensure -vendor-only # download Go dependencies
+    make llvm-source        # download LLVM
 
-Note that Clang and LLD must be placed inside the tools subdirectory of LLVM to
-be automatically built with the rest of the system.
+You can also store LLVM outside of the TinyGo root directory by setting the
+`LLVM_BUILDDIR`, `CLANG_SRC` and `LLD_SRC` make variables, but that is not
+covered by this guide.
 
 ## Build LLVM, Clang, LLD
 
-Building LLVM is quite easy compared to some other software packages. However,
-the default configuration is _not_ optimized for distribution. It is optimized
-for development, meaning that binaries produce accurate error messages at the
-cost of huge binaries and slow compiles.
-
-Before configuring, you may want to set the following environment variables to
-speed up the build. Most Linux distributions ship with GCC as the default
-compiler, but Clang is significantly faster and uses much less memory while
-producing binaries that are about as fast.
+Before starting the build, you may want to set the following environment
+variables to speed up the build. Most Linux distributions ship with GCC as the
+default compiler, but Clang is significantly faster and uses much less memory
+while producing binaries that are about as fast.
 
     export CC=clang
     export CXX=clang++
 
-Make a build directory. LLVM requires out-of-tree builds:
+The Makefile includes a default configuration that is good for most users. It
+builds a release version of LLVM (optimized, no asserts) and includes all
+targets supported by TinyGo:
 
-    mkdir $HOME/src/llvm-build
-    cd $HOME/src/llvm-build
-
-Configure LLVM with CMake:
-
-    cmake -G Ninja ../llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR;WebAssembly" -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=OFF -DLIBCLANG_BUILD_STATIC=ON
-
-You can also choose a different build system than Ninja, but Ninja is fast.
-
-There are various options you can tune here, but the options given above are
-preferable for releases. Here is what they do:
-
-  * `LLVM_TARGETS_TO_BUILD` and `LLVM_EXPERIMENTAL_TARGETS_TO_BUILD`: the
-    targets that are natively supported by the LLVM code generators. The targets
-    listed here are the ones supported by TinyGo. Note that LLVM is a cross
-    compiler by default, unlike some other compilers.
-  * `CMAKE_BUILD_TYPE`: the default is Debug, which produces large inefficient
-    binaries that are easy to debug. We want small and fast binaries.
-  * `LLVM_ENABLE_ASSERTIONS`: the default is ON, which greatly slows down LLVM
-    and is only really useful during development. Disable them here.
-  * `LIBCLANG_BUILD_STATIC`: unlike LLVM, libclang is built as a shared library
-    by default. We want a static library for easy distribution.
-
-Now build it:
-
-    ninja # or make, if you choose make in the previous step
+    make llvm-build
 
 This can take over an hour depending on the speed of your system.
 
 ## Build TinyGo
 
-Now that you have a working version of LLVM, build TinyGo using it. You need to
-specify the directories to the LLVM build directory and to the Clang and LLD source.
+The last step of course is to build TinyGo itself. This can again be done with
+make:
 
-    cd $HOME/go/src/github.com/tinygo-org/tinygo
-    make static LLVM_BUILDDIR=$HOME/src/llvm-build CLANG_SRC=$HOME/src/llvm/tools/clang LLD_SRC=$HOME/src/llvm/tools/lld
+    make
 
 ## Verify TinyGo
 
@@ -109,14 +77,12 @@ The result should not contain libclang or libLLVM.
 
 ## Make a release tarball
 
-Now that we have a working static build, it's time to make a release tarball.
-This is just a slight change from the command to build TinyGo:
+Now that we have a working static build, it's time to make a release tarball:
 
-    cd $HOME/go/src/github.com/tinygo-org/tinygo
-    make release LLVM_BUILDDIR=$HOME/src/llvm-build CLANG_SRC=$HOME/src/llvm/tools/clang LLD_SRC=$HOME/src/llvm/tools/lld
+    make release
 
 The release tarball is stored in build/release.tar.gz, and can be extracted with
-the following command:
+the following command (for example in ~/lib):
 
     tar -xvf path/to/release.tar.gz
 

CHANGELOG.md

@@ -1,3 +1,38 @@
+0.5.0
+---
+- **compiler driver**
+  - use `wasm-ld` instead of `wasm-ld-8` on macOS
+  - drop dependency on `llvm-ar`
+  - fix linker script includes when running outside `TINYGOROOT`
+- **compiler**
+  - switch to LLVM 8
+  - add support for the Go 1.12 standard library (Go 1.11 is still supported)
+  - work around lack of escape analysis due to nil checks
+  - implement casting named structs and pointers to them
+  - fix int casting to use the source signedness
+  - fix some bugs around `make([]T, …)` with uncommon index types
+  - some other optimizations
+  - support interface asserts in interp for "math/rand" support
+  - resolve all func value targets at compile time (wasm-only at the moment)
+- **cgo**
+  - improve diagnostics
+  - implement C `struct`, `union`, and arrays
+  - fix CGo-related crash in libclang
+  - implement `C.struct_` types
+- **targets**
+  - all baremetal: pretend to be linux/arm instead of js/wasm
+  - `avr`: improve `uintptr` support
+  - `cortexm`: implement memmove intrinsic generated by LLVM
+  - `cortexm`: use the lld linker instead of `arm-none-eabi-ld`
+  - `darwin`: use custom syscall package that links to libSystem.dylib
+  - `microbit`: add blink example
+  - `samd21`: support I2C1
+  - `samd21`: machine/atsamd21: correct pad/pin handling when using both UART
+     and USBCDC interfaces at same time
+  - `stm32f4discovery`: add support for this board
+  - `wasm`: support async func values
+  - `wasm`: improve documentation and add extra example
+
 0.4.1
 ---
 - **compiler**

Dockerfile

@@ -1,17 +1,20 @@
-# TinyGo base stage just installs LLVM 7 and the TinyGo compiler itself.
+# TinyGo base stage just installs LLVM 8 and the TinyGo compiler itself.
 FROM golang:latest AS tinygo-base
 
 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
-    echo "deb http://apt.llvm.org/stretch/ llvm-toolchain-stretch-7 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/stretch/ llvm-toolchain-stretch-8 main" >> /etc/apt/sources.list && \
     apt-get update && \
-    apt-get install -y llvm-7-dev libclang-7-dev git
+    apt-get install -y llvm-8-dev libclang-8-dev git
 
 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 && \
@@ -25,9 +28,9 @@ COPY --from=tinygo-base /go/src/github.com/tinygo-org/tinygo/src /go/src/github.
 COPY --from=tinygo-base /go/src/github.com/tinygo-org/tinygo/targets /go/src/github.com/tinygo-org/tinygo/targets
 
 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
-    echo "deb http://apt.llvm.org/stretch/ llvm-toolchain-stretch-7 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/stretch/ llvm-toolchain-stretch-8 main" >> /etc/apt/sources.list && \
     apt-get update && \
-    apt-get install -y libllvm7 lld-7
+    apt-get install -y libllvm8 lld-8
 
 # tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
 FROM tinygo-base AS tinygo-avr
@@ -59,7 +62,7 @@ COPY --from=tinygo-base /go/src/github.com/tinygo-org/tinygo/lib /go/src/github.
 
 RUN cd /go/src/github.com/tinygo-org/tinygo/ && \
     apt-get update && \
-    apt-get install -y apt-utils python3 make binutils-arm-none-eabi clang-7 && \
+    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 autoremove -y && \
@@ -74,7 +77,7 @@ COPY --from=tinygo-base /go/src/github.com/tinygo-org/tinygo/lib /go/src/github.
 
 RUN cd /go/src/github.com/tinygo-org/tinygo/ && \
     apt-get update && \
-    apt-get install -y apt-utils python3 make binutils-arm-none-eabi clang-7 binutils-avr gcc-avr avr-libc && \
+    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 autoremove -y && \

Gopkg.lock

@@ -1,6 +1,14 @@
 # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
 
 
+[[projects]]
+  branch = "master"
+  digest = "1:06519a2ec1d59040eaccec40206f9d0b59dc662db2a032f974d6d6b9a2bcb839"
+  name = "github.com/blakesmith/ar"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "8bd4349a67f2533b078dbc524689d15dba0f4659"
+
 [[projects]]
   branch = "master"
   digest = "1:00b45e06c7843541372fc17d982242bd6adfc2fc382b6f2e9ef9ce53d87a50b9"
@@ -19,20 +27,21 @@
     "go/types/typeutil",
   ]
   pruneopts = "UT"
-  revision = "3744606dbb67b99c60d3f11cb10bd3f9e6dad472"
+  revision = "8dcc6e70cdefe9a82236b6e195e4f4e2108fcb9f"
 
 [[projects]]
-  branch = "master"
-  digest = "1:a6a25fd8906c74978f1ed811bc9fd3422da8093be863b458874b02a782b6ae3e"
+  branch = "llvm8"
+  digest = "1:bf5539bdf6b3cc3ec1e45926db05d81180da11ce722fa1edcce3f0b4e1967da5"
   name = "tinygo.org/x/go-llvm"
   packages = ["."]
   pruneopts = "UT"
-  revision = "d5f730401f5069618b275a5241c6417eb0c38a65"
+  revision = "7707ae5d1261a8929edea7336c8087ca8b520d8d"
 
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
   input-imports = [
+    "github.com/blakesmith/ar",
     "github.com/marcinbor85/gohex",
     "golang.org/x/tools/go/ast/astutil",
     "golang.org/x/tools/go/ssa",

Gopkg.toml

@@ -1,5 +1,5 @@
 [[constraint]]
-  branch = "master"
+  branch = "llvm8"
   name = "tinygo.org/x/go-llvm"
 
 [[constraint]]

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

@@ -3,48 +3,24 @@
 all: tinygo
 tinygo: build/tinygo
 
-.PHONY: all tinygo static run-test run-blinky run-blinky2 clean fmt gen-device gen-device-nrf gen-device-avr
+.PHONY: all tinygo build/tinygo test llvm-build llvm-source clean fmt gen-device gen-device-nrf gen-device-avr
 
-TARGET ?= unix
-
-ifeq ($(TARGET),unix)
-# Regular *nix system.
-
-else ifeq ($(TARGET),pca10040)
-# PCA10040: nRF52832 development board
-OBJCOPY = arm-none-eabi-objcopy
-TGOFLAGS += -target $(TARGET)
-
-else ifeq ($(TARGET),microbit)
-# BBC micro:bit
-OBJCOPY = arm-none-eabi-objcopy
-TGOFLAGS += -target $(TARGET)
-
-else ifeq ($(TARGET),reelboard)
-# reel board
-OBJCOPY = arm-none-eabi-objcopy
-TGOFLAGS += -target $(TARGET)
-
-else ifeq ($(TARGET),bluepill)
-# "blue pill" development board
-# See: https://wiki.stm32duino.com/index.php?title=Blue_Pill
-OBJCOPY = arm-none-eabi-objcopy
-TGOFLAGS += -target $(TARGET)
-
-else ifeq ($(TARGET),arduino)
-OBJCOPY = avr-objcopy
-TGOFLAGS += -target $(TARGET)
-
-else
-$(error Unknown target)
-
-endif
+# Default build and source directories, as created by `make llvm-build`.
+LLVM_BUILDDIR ?= llvm-build
+CLANG_SRC ?= llvm/tools/clang
+LLD_SRC ?= llvm/tools/lld
 
 LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines debuginfodwarf executionengine instrumentation interpreter ipo irreader linker lto mc mcjit objcarcopts option profiledata scalaropts support target
 
-CLANG_LIBS = -Wl,--start-group $(abspath $(LLVM_BUILDDIR))/lib/libclang.a -lclangAnalysis -lclangARCMigrate -lclangAST -lclangASTMatchers -lclangBasic -lclangCodeGen -lclangCrossTU -lclangDriver -lclangDynamicASTMatchers -lclangEdit -lclangFormat -lclangFrontend -lclangFrontendTool -lclangHandleCXX -lclangHandleLLVM -lclangIndex -lclangLex -lclangParse -lclangRewrite -lclangRewriteFrontend -lclangSema -lclangSerialization -lclangStaticAnalyzerCheckers -lclangStaticAnalyzerCore -lclangStaticAnalyzerFrontend -lclangTooling -lclangToolingASTDiff -lclangToolingCore -lclangToolingInclusions -lclangToolingRefactor -Wl,--end-group -lstdc++
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Linux)
+    START_GROUP = -Wl,--start-group
+    END_GROUP = -Wl,--end-group
+endif
 
-LLD_LIBS = -Wl,--start-group -llldCOFF -llldCommon -llldCore -llldDriver -llldELF -llldMachO -llldMinGW -llldReaderWriter -llldWasm -llldYAML -Wl,--end-group
+CLANG_LIBS = $(START_GROUP) $(abspath $(LLVM_BUILDDIR))/lib/libclang.a -lclangAnalysis -lclangARCMigrate -lclangAST -lclangASTMatchers -lclangBasic -lclangCodeGen -lclangCrossTU -lclangDriver -lclangDynamicASTMatchers -lclangEdit -lclangFormat -lclangFrontend -lclangFrontendTool -lclangHandleCXX -lclangHandleLLVM -lclangIndex -lclangLex -lclangParse -lclangRewrite -lclangRewriteFrontend -lclangSema -lclangSerialization -lclangStaticAnalyzerCheckers -lclangStaticAnalyzerCore -lclangStaticAnalyzerFrontend -lclangTooling -lclangToolingASTDiff -lclangToolingCore -lclangToolingInclusions -lclangToolingRefactor $(END_GROUP) -lstdc++
+
+LLD_LIBS = $(START_GROUP) -llldCOFF -llldCommon -llldCore -llldDriver -llldELF -llldMachO -llldMinGW -llldReaderWriter -llldWasm -llldYAML $(END_GROUP)
 
 
 # For static linking.
@@ -53,40 +29,14 @@ CGO_CXXFLAGS=-std=c++11
 CGO_LDFLAGS=-L$(LLVM_BUILDDIR)/lib $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS))
 
 
-
-run-test: build/test
-	./build/test
-
-run-blinky: run-blinky2
-run-blinky2: build/blinky2
-	./build/blinky2
-
-ifeq ($(TARGET),pca10040)
-flash-%: build/%.hex
-	nrfjprog -f nrf52 --sectorerase --program $< --reset
-else ifeq ($(TARGET),microbit)
-flash-%: build/%.hex
-	openocd -f interface/cmsis-dap.cfg -f target/nrf51.cfg -c 'program $< reset exit'
-else ifeq ($(TARGET),reelboard)
-flash-%: build/%.hex
-	openocd -f interface/cmsis-dap.cfg -f target/nrf51.cfg -c 'program $< reset exit'
-else ifeq ($(TARGET),arduino)
-flash-%: build/%.hex
-	avrdude -c arduino -p atmega328p -P /dev/ttyACM0 -U flash:w:$<
-else ifeq ($(TARGET),bluepill)
-flash-%: build/%.hex
-	openocd -f interface/stlink-v2.cfg -f target/stm32f1x.cfg -c 'program $< reset exit'
-endif
-
 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:
-	@go fmt . ./compiler ./interp ./loader ./ir ./src/device/arm ./src/examples/* ./src/machine ./src/os ./src/runtime ./src/sync
-	@go fmt ./testdata/*.go
-
-test:
-	@go test -v .
+	@gofmt -l -w $(FMT_PATHS)
+fmt-check:
+	@unformatted=$$(gofmt -l $(FMT_PATHS)); [ -z "$$unformatted" ] && exit 0; echo "Unformatted:"; for fn in $$unformatted; do echo "  $$fn"; done; exit 1
 
 gen-device: gen-device-avr gen-device-nrf gen-device-sam gen-device-stm32
 
@@ -107,23 +57,45 @@ gen-device-stm32:
 	./tools/gen-device-svd.py lib/cmsis-svd/data/STMicro/ src/device/stm32/ --source=https://github.com/posborne/cmsis-svd/tree/master/data/STMicro
 	go fmt ./src/device/stm32
 
+
+# Get LLVM sources.
+llvm/README.txt:
+	git clone -b release_80 https://github.com/llvm-mirror/llvm.git llvm
+llvm/tools/clang/README.txt:
+	git clone -b release_80 https://github.com/llvm-mirror/clang.git llvm/tools/clang
+llvm/tools/lld/README.md:
+	git clone -b release_80 https://github.com/llvm-mirror/lld.git llvm/tools/lld
+llvm-source: llvm/README.txt llvm/tools/clang/README.txt llvm/tools/lld/README.md
+
+# 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 -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF
+
+# Build LLVM.
+llvm-build: llvm-build/build.ninja
+	cd llvm-build; ninja
+
+
 # Build the Go compiler.
 build/tinygo:
-	@mkdir -p build
-	go build -o build/tinygo .
-
-static:
+	@if [ ! -f llvm-build/bin/llvm-config ]; then echo "Fetch and build LLVM first by running:\n  make llvm-source\n  make llvm-build"; exit 1; fi
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" go build -o build/tinygo -tags byollvm .
 
-release: static gen-device
+test:
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" go test -v -tags byollvm .
+
+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
@@ -136,15 +108,3 @@ release: static gen-device
 	./build/tinygo build-builtins -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/compiler-rt.a
 	./build/tinygo build-builtins -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/compiler-rt.a
 	tar -czf build/release.tar.gz -C build/release tinygo
-
-# Binary that can run on the host.
-build/%: src/examples/% src/examples/%/*.go build/tinygo src/runtime/*.go
-	./build/tinygo build $(TGOFLAGS) -size=short -o $@ $(subst src/,,$<)
-
-# ELF file that can run on a microcontroller.
-build/%.elf: src/examples/% src/examples/%/*.go build/tinygo src/runtime/*.go
-	./build/tinygo build $(TGOFLAGS) -size=short -o $@ $(subst src/,,$<)
-
-# Convert executable to Intel hex file (for flashing).
-build/%.hex: build/%.elf
-	$(OBJCOPY) -O ihex $^ $@

README.md

@@ -1,6 +1,5 @@
 # TinyGo - Go compiler for small places
 
-[![Travis CI](https://travis-ci.com/tinygo-org/tinygo.svg?branch=dev)](https://travis-ci.com/tinygo-org/tinygo)
 [![CircleCI](https://circleci.com/gh/tinygo-org/tinygo/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/tinygo/tree/dev)
 
 TinyGo is a Go compiler intended for use in small places such as microcontrollers, WebAssembly (WASM), and command-line tools.

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

@@ -1,11 +1,15 @@
 package main
 
 import (
+	"errors"
+	"io"
 	"io/ioutil"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
+	"time"
+
+	"github.com/blakesmith/ar"
 )
 
 // These are the GENERIC_SOURCES according to CMakeList.txt.
@@ -187,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
 	})
@@ -235,28 +239,56 @@ 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}
 		}
 	}
 
 	// Put all builtins in an archive to link as a static library.
+	// Note: this does not create a symbol index, but ld.lld doesn't seem to
+	// care.
 	arpath := filepath.Join(dir, "librt.a")
-	cmd := exec.Command(commands["ar"], append([]string{"cr", arpath}, objs...)...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Dir = dir
-	err = cmd.Run()
+	arfile, err := os.Create(arpath)
 	if err != nil {
-		return &commandError{"failed to make static library", arpath, err}
+		return err
+	}
+	defer arfile.Close()
+	arwriter := ar.NewWriter(arfile)
+	err = arwriter.WriteGlobalHeader()
+	if err != nil {
+		return &os.PathError{"write ar header", arpath, err}
+	}
+	for _, objpath := range objs {
+		name := filepath.Base(objpath)
+		objfile, err := os.Open(objpath)
+		if err != nil {
+			return err
+		}
+		defer objfile.Close()
+		st, err := objfile.Stat()
+		if err != nil {
+			return err
+		}
+		arwriter.WriteHeader(&ar.Header{
+			Name:    name,
+			ModTime: time.Unix(0, 0),
+			Uid:     0,
+			Gid:     0,
+			Mode:    0644,
+			Size:    st.Size(),
+		})
+		n, err := io.Copy(arwriter, objfile)
+		if err != nil {
+			return err
+		}
+		if n != st.Size() {
+			return errors.New("file modified during ar creation: " + arpath)
+		}
 	}
 
 	// 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)
 }

commands.go

@@ -1,11 +1,33 @@
-// +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{
-	"ar":      "llvm-ar-7",
-	"clang":   "clang-7",
-	"ld.lld":  "ld.lld-7",
-	"wasm-ld": "wasm-ld-7",
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"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 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,11 +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{
-	"ar":      "llvm-ar",
-	"clang":   "clang-7",
-	"ld.lld":  "ld.lld-7",
-	"wasm-ld": "wasm-ld-7",
-}

compiler/asserts.go

@@ -51,6 +51,11 @@ func (c *Compiler) emitLookupBoundsCheck(frame *Frame, arrayLen, index llvm.Valu
 
 // emitSliceBoundsCheck emits a bounds check before a slicing operation to make
 // sure it is within bounds.
+//
+// This function is both used for slicing a slice (low and high have their
+// normal meaning) and for creating a new slice, where 'capacity' means the
+// biggest possible slice capacity, 'low' means len and 'high' means cap. The
+// logic is the same in both cases.
 func (c *Compiler) emitSliceBoundsCheck(frame *Frame, capacity, low, high llvm.Value, lowType, highType *types.Basic) {
 	if frame.fn.IsNoBounds() {
 		// The //go:nobounds pragma was added to the function to avoid bounds
@@ -115,8 +120,23 @@ func (c *Compiler) emitNilCheck(frame *Frame, ptr llvm.Value, blockPrefix string
 	frame.blockExits[frame.currentBlock] = nextBlock // adjust outgoing block for phi nodes
 
 	// Compare against nil.
-	nilptr := llvm.ConstPointerNull(ptr.Type())
-	isnil := c.builder.CreateICmp(llvm.IntEQ, ptr, nilptr, "")
+	var isnil llvm.Value
+	if ptr.Type().PointerAddressSpace() == 0 {
+		// Do the nil check using the isnil builtin, which marks the parameter
+		// as nocapture.
+		// The reason it has to go through a builtin, is that a regular icmp
+		// instruction may capture the pointer in LLVM semantics, see
+		// https://reviews.llvm.org/D60047 for details. Pointer capturing
+		// unfortunately breaks escape analysis, so we use this trick to let the
+		// functionattr pass know that this pointer doesn't really escape.
+		ptr = c.builder.CreateBitCast(ptr, c.i8ptrType, "")
+		isnil = c.createRuntimeCall("isnil", []llvm.Value{ptr}, "")
+	} else {
+		// Do the nil check using a regular icmp. This can happen with function
+		// pointers on AVR, which don't benefit from escape analysis anyway.
+		nilptr := llvm.ConstPointerNull(ptr.Type())
+		isnil = c.builder.CreateICmp(llvm.IntEQ, ptr, nilptr, "")
+	}
 	c.builder.CreateCondBr(isnil, faultBlock, nextBlock)
 
 	// Fail: this is a nil pointer, exit with a panic.

compiler/calls.go

@@ -123,10 +123,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,64 @@ 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
-	}
+func (c *Compiler) emitChanSend(frame *Frame, instr *ssa.Send) {
+	valueType := c.getLLVMType(instr.X.Type())
+	ch := c.getValue(frame, instr.Chan)
+	chanValue := c.getValue(frame, instr.X)
 	valueSize := llvm.ConstInt(c.uintptrType, c.targetData.TypeAllocSize(chanValue.Type()), false)
+	coroutine := c.createRuntimeCall("getCoroutine", nil, "")
+
+	// store value-to-send
+	c.builder.SetInsertPointBefore(coroutine.InstructionParent().Parent().EntryBasicBlock().FirstInstruction())
 	valueAlloca := c.builder.CreateAlloca(valueType, "chan.value")
+	c.builder.SetInsertPointBefore(coroutine)
+	c.builder.SetInsertPointAtEnd(coroutine.InstructionParent())
 	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.
+	c.createRuntimeCall("chanSend", []llvm.Value{coroutine, ch, valueAllocaCast, valueSize}, "")
+
+	// Make sure CoroSplit includes the alloca in the coroutine frame.
+	// This is a bit dirty, but it works (at least in LLVM 8).
+	valueSizeI64 := llvm.ConstInt(c.ctx.Int64Type(), c.targetData.TypeAllocSize(chanValue.Type()), false)
+	c.builder.CreateCall(c.getLifetimeEndFunc(), []llvm.Value{valueSizeI64, valueAllocaCast}, "")
 }
 
 // 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())
 	valueSize := llvm.ConstInt(c.uintptrType, c.targetData.TypeAllocSize(valueType), false)
-	ch, err := c.parseExpr(frame, unop.X)
-	if err != nil {
-		return llvm.Value{}, err
-	}
+	ch := c.getValue(frame, unop.X)
+	coroutine := c.createRuntimeCall("getCoroutine", nil, "")
+
+	// Allocate memory to receive into.
+	c.builder.SetInsertPointBefore(coroutine.InstructionParent().Parent().EntryBasicBlock().FirstInstruction())
 	valueAlloca := c.builder.CreateAlloca(valueType, "chan.value")
+	c.builder.SetInsertPointBefore(coroutine)
+	c.builder.SetInsertPointAtEnd(coroutine.InstructionParent())
 	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}, "")
+
+	// Do the receive.
+	c.createRuntimeCall("chanRecv", []llvm.Value{coroutine, ch, valueAllocaCast, valueSize}, "")
 	received := c.builder.CreateLoad(valueAlloca, "chan.received")
 	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

@@ -0,0 +1,269 @@
+package compiler
+
+// This file lowers func values into their final form. This is necessary for
+// funcValueSwitch, which needs full program analysis.
+
+import (
+	"sort"
+	"strconv"
+
+	"tinygo.org/x/go-llvm"
+)
+
+// funcSignatureInfo keeps information about a single signature and its uses.
+type funcSignatureInfo struct {
+	sig                     llvm.Value   // *uint8 to identify the signature
+	funcValueWithSignatures []llvm.Value // slice of runtime.funcValueWithSignature
+}
+
+// funcWithUses keeps information about a single function used as func value and
+// the assigned function ID. More commonly used functions are assigned a lower
+// ID.
+type funcWithUses struct {
+	funcPtr  llvm.Value
+	useCount int // how often this function is used in a func value
+	id       int // assigned ID
+}
+
+// Slice to sort functions by their use counts, or else their name if they're
+// used equally often.
+type funcWithUsesList []*funcWithUses
+
+func (l funcWithUsesList) Len() int { return len(l) }
+func (l funcWithUsesList) Less(i, j int) bool {
+	if l[i].useCount != l[j].useCount {
+		// return the reverse: we want the highest use counts sorted first
+		return l[i].useCount > l[j].useCount
+	}
+	iName := l[i].funcPtr.Name()
+	jName := l[j].funcPtr.Name()
+	return iName < jName
+}
+func (l funcWithUsesList) Swap(i, j int) {
+	l[i], l[j] = l[j], l[i]
+}
+
+// LowerFuncValue lowers the runtime.funcValueWithSignature type and
+// runtime.getFuncPtr function to their final form.
+func (c *Compiler) LowerFuncValues() {
+	if c.funcImplementation() != funcValueSwitch {
+		return
+	}
+
+	// Find all func values used in the program with their signatures.
+	funcValueWithSignaturePtr := llvm.PointerType(c.mod.GetTypeByName("runtime.funcValueWithSignature"), 0)
+	signatures := map[string]*funcSignatureInfo{}
+	for global := c.mod.FirstGlobal(); !global.IsNil(); global = llvm.NextGlobal(global) {
+		if global.Type() != funcValueWithSignaturePtr {
+			continue
+		}
+		sig := llvm.ConstExtractValue(global.Initializer(), []uint32{1})
+		name := sig.Name()
+		if info, ok := signatures[name]; ok {
+			info.funcValueWithSignatures = append(info.funcValueWithSignatures, global)
+		} else {
+			signatures[name] = &funcSignatureInfo{
+				sig:                     sig,
+				funcValueWithSignatures: []llvm.Value{global},
+			}
+		}
+	}
+
+	// Sort the signatures, for deterministic execution.
+	names := make([]string, 0, len(signatures))
+	for name := range signatures {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	for _, name := range names {
+		info := signatures[name]
+		functions := make(funcWithUsesList, len(info.funcValueWithSignatures))
+		for i, use := range info.funcValueWithSignatures {
+			var useCount int
+			for _, use2 := range getUses(use) {
+				useCount += len(getUses(use2))
+			}
+			functions[i] = &funcWithUses{
+				funcPtr:  llvm.ConstExtractValue(use.Initializer(), []uint32{0}).Operand(0),
+				useCount: useCount,
+			}
+		}
+		sort.Sort(functions)
+
+		for i, fn := range functions {
+			fn.id = i + 1
+			for _, ptrtoint := range getUses(fn.funcPtr) {
+				if ptrtoint.IsAConstantExpr().IsNil() || ptrtoint.Opcode() != llvm.PtrToInt {
+					continue
+				}
+				for _, funcValueWithSignatureConstant := range getUses(ptrtoint) {
+					for _, funcValueWithSignatureGlobal := range getUses(funcValueWithSignatureConstant) {
+						for _, use := range getUses(funcValueWithSignatureGlobal) {
+							if ptrtoint.IsAConstantExpr().IsNil() || ptrtoint.Opcode() != llvm.PtrToInt {
+								panic("expected const ptrtoint")
+							}
+							use.ReplaceAllUsesWith(llvm.ConstInt(c.uintptrType, uint64(fn.id), false))
+						}
+					}
+				}
+			}
+		}
+
+		for _, getFuncPtrCall := range getUses(info.sig) {
+			if getFuncPtrCall.IsACallInst().IsNil() {
+				continue
+			}
+			if getFuncPtrCall.CalledValue().Name() != "runtime.getFuncPtr" {
+				panic("expected all call uses to be runtime.getFuncPtr")
+			}
+			funcID := getFuncPtrCall.Operand(1)
+			switch len(functions) {
+			case 0:
+				// There are no functions used in a func value that implement
+				// this signature. The only possible value is a nil value.
+				for _, inttoptr := range getUses(getFuncPtrCall) {
+					if inttoptr.IsAIntToPtrInst().IsNil() {
+						panic("expected inttoptr")
+					}
+					nilptr := llvm.ConstPointerNull(inttoptr.Type())
+					inttoptr.ReplaceAllUsesWith(nilptr)
+					inttoptr.EraseFromParentAsInstruction()
+				}
+				getFuncPtrCall.EraseFromParentAsInstruction()
+			case 1:
+				// There is exactly one function with this signature that is
+				// used in a func value. The func value itself can be either nil
+				// or this one function.
+				c.builder.SetInsertPointBefore(getFuncPtrCall)
+				zero := llvm.ConstInt(c.uintptrType, 0, false)
+				isnil := c.builder.CreateICmp(llvm.IntEQ, funcID, zero, "")
+				funcPtrNil := llvm.ConstPointerNull(functions[0].funcPtr.Type())
+				funcPtr := c.builder.CreateSelect(isnil, funcPtrNil, functions[0].funcPtr, "")
+				for _, inttoptr := range getUses(getFuncPtrCall) {
+					if inttoptr.IsAIntToPtrInst().IsNil() {
+						panic("expected inttoptr")
+					}
+					inttoptr.ReplaceAllUsesWith(funcPtr)
+					inttoptr.EraseFromParentAsInstruction()
+				}
+				getFuncPtrCall.EraseFromParentAsInstruction()
+			default:
+				// There are multiple functions used in a func value that
+				// implement this signature.
+				// What we'll do is transform the following:
+				//     rawPtr := runtime.getFuncPtr(fn)
+				//     if func.rawPtr == nil {
+				//         runtime.nilpanic()
+				//     }
+				//     result := func.rawPtr(...args, func.context)
+				// into this:
+				//     if false {
+				//         runtime.nilpanic()
+				//     }
+				//     var result // Phi
+				//     switch fn.id {
+				//     case 0:
+				//         runtime.nilpanic()
+				//     case 1:
+				//         result = call first implementation...
+				//     case 2:
+				//         result = call second implementation...
+				//     default:
+				//         unreachable
+				//     }
+
+				// Remove some casts, checks, and the old call which we're going
+				// to replace.
+				var funcCall llvm.Value
+				for _, inttoptr := range getUses(getFuncPtrCall) {
+					if inttoptr.IsAIntToPtrInst().IsNil() {
+						panic("expected inttoptr")
+					}
+					for _, ptrUse := range getUses(inttoptr) {
+						if !ptrUse.IsABitCastInst().IsNil() {
+							for _, bitcastUse := range getUses(ptrUse) {
+								if bitcastUse.IsACallInst().IsNil() || bitcastUse.CalledValue().Name() != "runtime.isnil" {
+									panic("expected a call to runtime.isnil")
+								}
+								bitcastUse.ReplaceAllUsesWith(llvm.ConstInt(c.ctx.Int1Type(), 0, false))
+								bitcastUse.EraseFromParentAsInstruction()
+							}
+							ptrUse.EraseFromParentAsInstruction()
+						} else if !ptrUse.IsACallInst().IsNil() && ptrUse.CalledValue() == inttoptr {
+							if !funcCall.IsNil() {
+								panic("multiple calls on a single runtime.getFuncPtr")
+							}
+							funcCall = ptrUse
+						} else {
+							panic("unexpected getFuncPtrCall")
+						}
+					}
+				}
+				if funcCall.IsNil() {
+					panic("expected exactly one call use of a runtime.getFuncPtr")
+				}
+
+				// The block that cannot be reached with correct funcValues (to
+				// help the optimizer).
+				c.builder.SetInsertPointBefore(funcCall)
+				defaultBlock := llvm.AddBasicBlock(funcCall.InstructionParent().Parent(), "func.default")
+				c.builder.SetInsertPointAtEnd(defaultBlock)
+				c.builder.CreateUnreachable()
+
+				// Create the switch.
+				c.builder.SetInsertPointBefore(funcCall)
+				sw := c.builder.CreateSwitch(funcID, defaultBlock, len(functions)+1)
+
+				// Split right after the switch. We will need to insert a few
+				// basic blocks in this gap.
+				nextBlock := c.splitBasicBlock(sw, llvm.NextBasicBlock(sw.InstructionParent()), "func.next")
+
+				// The 0 case, which is actually a nil check.
+				nilBlock := llvm.InsertBasicBlock(nextBlock, "func.nil")
+				c.builder.SetInsertPointAtEnd(nilBlock)
+				c.createRuntimeCall("nilpanic", nil, "")
+				c.builder.CreateUnreachable()
+				sw.AddCase(llvm.ConstInt(c.uintptrType, 0, false), nilBlock)
+
+				// Gather the list of parameters for every call we're going to
+				// make.
+				callParams := make([]llvm.Value, funcCall.OperandsCount()-1)
+				for i := range callParams {
+					callParams[i] = funcCall.Operand(i)
+				}
+
+				// If the call produces a value, we need to get it using a PHI
+				// node.
+				phiBlocks := make([]llvm.BasicBlock, len(functions))
+				phiValues := make([]llvm.Value, len(functions))
+				for i, fn := range functions {
+					// Insert a switch case.
+					bb := llvm.InsertBasicBlock(nextBlock, "func.call"+strconv.Itoa(fn.id))
+					c.builder.SetInsertPointAtEnd(bb)
+					result := c.builder.CreateCall(fn.funcPtr, callParams, "")
+					c.builder.CreateBr(nextBlock)
+					sw.AddCase(llvm.ConstInt(c.uintptrType, uint64(fn.id), false), bb)
+					phiBlocks[i] = bb
+					phiValues[i] = result
+				}
+				// Create the PHI node so that the call result flows into the
+				// next block (after the split). This is only necessary when the
+				// call produced a value.
+				if funcCall.Type().TypeKind() != llvm.VoidTypeKind {
+					c.builder.SetInsertPointBefore(nextBlock.FirstInstruction())
+					phi := c.builder.CreatePHI(funcCall.Type(), "")
+					phi.AddIncoming(phiValues, phiBlocks)
+					funcCall.ReplaceAllUsesWith(phi)
+				}
+
+				// Finally, remove the old instructions.
+				funcCall.EraseFromParentAsInstruction()
+				for _, inttoptr := range getUses(getFuncPtrCall) {
+					inttoptr.EraseFromParentAsInstruction()
+				}
+				getFuncPtrCall.EraseFromParentAsInstruction()
+			}
+		}
+	}
+}

compiler/func.go

@@ -0,0 +1,202 @@
+package compiler
+
+// This file implements function values and closures. It may need some lowering
+// in a later step, see func-lowering.go.
+
+import (
+	"go/types"
+
+	"golang.org/x/tools/go/ssa"
+	"tinygo.org/x/go-llvm"
+)
+
+type funcValueImplementation int
+
+const (
+	funcValueNone funcValueImplementation = iota
+
+	// A func value is implemented as a pair of pointers:
+	//     {context, function pointer}
+	// where the context may be a pointer to a heap-allocated struct containing
+	// the free variables, or it may be undef if the function being pointed to
+	// doesn't need a context. The function pointer is a regular function
+	// pointer.
+	funcValueDoubleword
+
+	// As funcValueDoubleword, but with the function pointer replaced by a
+	// unique ID per function signature. Function values are called by using a
+	// switch statement and choosing which function to call.
+	funcValueSwitch
+)
+
+// funcImplementation picks an appropriate func value implementation for the
+// target.
+func (c *Compiler) funcImplementation() funcValueImplementation {
+	if c.GOARCH == "wasm" {
+		return funcValueSwitch
+	} else {
+		return funcValueDoubleword
+	}
+}
+
+// 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 {
+	var funcValueScalar llvm.Value
+	switch c.funcImplementation() {
+	case funcValueDoubleword:
+		// Closure is: {context, function pointer}
+		funcValueScalar = funcPtr
+	case funcValueSwitch:
+		sigGlobal := c.getFuncSignature(sig)
+		funcValueWithSignatureGlobalName := funcPtr.Name() + "$withSignature"
+		funcValueWithSignatureGlobal := c.mod.NamedGlobal(funcValueWithSignatureGlobalName)
+		if funcValueWithSignatureGlobal.IsNil() {
+			funcValueWithSignatureType := c.mod.GetTypeByName("runtime.funcValueWithSignature")
+			funcValueWithSignature := llvm.ConstNamedStruct(funcValueWithSignatureType, []llvm.Value{
+				llvm.ConstPtrToInt(funcPtr, c.uintptrType),
+				sigGlobal,
+			})
+			funcValueWithSignatureGlobal = llvm.AddGlobal(c.mod, funcValueWithSignatureType, funcValueWithSignatureGlobalName)
+			funcValueWithSignatureGlobal.SetInitializer(funcValueWithSignature)
+			funcValueWithSignatureGlobal.SetGlobalConstant(true)
+			funcValueWithSignatureGlobal.SetLinkage(llvm.InternalLinkage)
+		}
+		funcValueScalar = llvm.ConstPtrToInt(funcValueWithSignatureGlobal, c.uintptrType)
+	default:
+		panic("unimplemented func value variant")
+	}
+	funcValueType := c.getFuncType(sig)
+	funcValue := llvm.Undef(funcValueType)
+	funcValue = c.builder.CreateInsertValue(funcValue, context, 0, "")
+	funcValue = c.builder.CreateInsertValue(funcValue, funcValueScalar, 1, "")
+	return funcValue
+}
+
+// getFuncSignature returns a global for identification of a particular function
+// signature. It is used in runtime.funcValueWithSignature and in calls to
+// getFuncPtr.
+func (c *Compiler) getFuncSignature(sig *types.Signature) llvm.Value {
+	typeCodeName := getTypeCodeName(sig)
+	sigGlobalName := "reflect/types.type:" + typeCodeName
+	sigGlobal := c.mod.NamedGlobal(sigGlobalName)
+	if sigGlobal.IsNil() {
+		sigGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), sigGlobalName)
+		sigGlobal.SetInitializer(llvm.Undef(c.ctx.Int8Type()))
+		sigGlobal.SetGlobalConstant(true)
+		sigGlobal.SetLinkage(llvm.InternalLinkage)
+	}
+	return sigGlobal
+}
+
+// extractFuncScalar returns some scalar that can be used in comparisons. It is
+// a cheap operation.
+func (c *Compiler) extractFuncScalar(funcValue llvm.Value) llvm.Value {
+	return c.builder.CreateExtractValue(funcValue, 1, "")
+}
+
+// extractFuncContext extracts the context pointer from this function value. It
+// is a cheap operation.
+func (c *Compiler) extractFuncContext(funcValue llvm.Value) llvm.Value {
+	return c.builder.CreateExtractValue(funcValue, 0, "")
+}
+
+// decodeFuncValue extracts the context and the function pointer from this func
+// value. This may be an expensive operation.
+func (c *Compiler) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value, err error) {
+	context = c.builder.CreateExtractValue(funcValue, 0, "")
+	switch c.funcImplementation() {
+	case funcValueDoubleword:
+		funcPtr = c.builder.CreateExtractValue(funcValue, 1, "")
+	case funcValueSwitch:
+		llvmSig := c.getRawFuncType(sig)
+		sigGlobal := c.getFuncSignature(sig)
+		funcPtr = c.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
+		funcPtr = c.builder.CreateIntToPtr(funcPtr, llvmSig, "")
+	default:
+		panic("unimplemented func value variant")
+	}
+	return
+}
+
+// getFuncType returns the type of a func value given a signature.
+func (c *Compiler) getFuncType(typ *types.Signature) llvm.Type {
+	switch c.funcImplementation() {
+	case funcValueDoubleword:
+		rawPtr := c.getRawFuncType(typ)
+		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false)
+	case funcValueSwitch:
+		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 {
+	// Get the return type.
+	var returnType llvm.Type
+	switch typ.Results().Len() {
+	case 0:
+		// No return values.
+		returnType = c.ctx.VoidType()
+	case 1:
+		// Just one return value.
+		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++ {
+			members[i] = c.getLLVMType(typ.Results().At(i).Type())
+		}
+		returnType = c.ctx.StructType(members, false)
+	}
+
+	// Get the parameter types.
+	var paramTypes []llvm.Type
+	if typ.Recv() != nil {
+		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.
+			recv = c.i8ptrType
+		}
+		paramTypes = append(paramTypes, c.expandFormalParamType(recv)...)
+	}
+	for i := 0; i < typ.Params().Len(); i++ {
+		subType := c.getLLVMType(typ.Params().At(i).Type())
+		paramTypes = append(paramTypes, c.expandFormalParamType(subType)...)
+	}
+	// All functions take these parameters at the end.
+	paramTypes = append(paramTypes, c.i8ptrType) // context
+	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)
+}
+
+// parseMakeClosure makes a function value (with context) from the given
+// closure expression.
+func (c *Compiler) parseMakeClosure(frame *Frame, expr *ssa.MakeClosure) (llvm.Value, error) {
+	if len(expr.Bindings) == 0 {
+		panic("unexpected: MakeClosure without bound variables")
+	}
+	f := c.ir.GetFunction(expr.Fn.(*ssa.Function))
+
+	// Collect all bound variables.
+	boundVars := make([]llvm.Value, len(expr.Bindings))
+	for i, binding := range expr.Bindings {
+		// The context stores the bound variables.
+		llvmBoundVar := c.getValue(frame, binding)
+		boundVars[i] = llvmBoundVar
+	}
+
+	// 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), 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
@@ -170,13 +173,17 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 	if !sleep.IsNil() {
 		worklist = append(worklist, sleep)
 	}
-	chanSendStub := c.mod.NamedFunction("runtime.chanSendStub")
-	if !chanSendStub.IsNil() {
-		worklist = append(worklist, chanSendStub)
+	deadlockStub := c.mod.NamedFunction("runtime.deadlockStub")
+	if !deadlockStub.IsNil() {
+		worklist = append(worklist, deadlockStub)
 	}
-	chanRecvStub := c.mod.NamedFunction("runtime.chanRecvStub")
-	if !chanRecvStub.IsNil() {
-		worklist = append(worklist, chanRecvStub)
+	chanSend := c.mod.NamedFunction("runtime.chanSend")
+	if !chanSend.IsNil() {
+		worklist = append(worklist, chanSend)
+	}
+	chanRecv := c.mod.NamedFunction("runtime.chanRecv")
+	if !chanRecv.IsNil() {
+		worklist = append(worklist, chanRecv)
 	}
 
 	if len(worklist) == 0 {
@@ -274,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)
 
@@ -288,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 == chanSendStub || f == chanRecvStub {
+		if f == sleep || f == deadlockStub || f == chanSend || f == chanRecv {
 			continue
 		}
 
@@ -305,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 == chanSendStub || callee == chanRecvStub {
+					if _, ok := asyncFuncs[callee]; !ok || callee == sleep || callee == deadlockStub || callee == chanSend || callee == chanRecv {
 						continue
 					}
 					asyncCalls = append(asyncCalls, inst)
@@ -343,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),
@@ -354,44 +366,63 @@ 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)
+
+			parentHandle := f.LastParam()
+
+			// 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(), 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()
 		}
 
 		// Coroutine cleanup. Free resources associated with this coroutine.
@@ -416,6 +447,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.
@@ -439,37 +478,31 @@ func (c *Compiler) markAsyncFunctions() (needsScheduler bool, err error) {
 		sleepCall.EraseFromParentAsInstruction()
 	}
 
-	// Transform calls to runtime.chanSendStub into channel send operations.
-	for _, sendOp := range getUses(chanSendStub) {
+	// Transform calls to runtime.deadlockStub into coroutine suspends (without
+	// resume).
+	for _, deadlockCall := range getUses(deadlockStub) {
+		// deadlockCall must be a call instruction.
+		frame := asyncFuncs[deadlockCall.InstructionParent().Parent()]
+
+		// Exit coroutine.
+		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
+		}, "")
+		c.splitBasicBlock(deadlockCall, llvm.NextBasicBlock(c.builder.GetInsertBlock()), "task.wakeup.dead")
+		c.builder.SetInsertPointBefore(deadlockCall)
+		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)
+		deadlockCall.EraseFromParentAsInstruction()
+	}
+
+	// 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{
@@ -482,21 +515,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{
@@ -508,32 +531,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

@@ -0,0 +1,155 @@
+package compiler
+
+// This file implements inline asm support by calling special functions.
+
+import (
+	"fmt"
+	"go/constant"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"golang.org/x/tools/go/ssa"
+	"tinygo.org/x/go-llvm"
+)
+
+// This is a compiler builtin, which reads the given register by name:
+//
+//     func ReadRegister(name string) uintptr
+//
+// The register name must be a constant, for example "sp".
+func (c *Compiler) emitReadRegister(args []ssa.Value) (llvm.Value, error) {
+	fnType := llvm.FunctionType(c.uintptrType, []llvm.Type{}, false)
+	regname := constant.StringVal(args[0].(*ssa.Const).Value)
+	target := llvm.InlineAsm(fnType, "mov $0, "+regname, "=r", false, false, 0)
+	return c.builder.CreateCall(target, nil, ""), nil
+}
+
+// This is a compiler builtin, which emits a piece of inline assembly with no
+// operands or return values. It is useful for trivial instructions, like wfi in
+// ARM or sleep in AVR.
+//
+//     func Asm(asm string)
+//
+// The provided assembly must be a constant.
+func (c *Compiler) emitAsm(args []ssa.Value) (llvm.Value, error) {
+	// Magic function: insert inline assembly instead of calling it.
+	fnType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{}, false)
+	asm := constant.StringVal(args[0].(*ssa.Const).Value)
+	target := llvm.InlineAsm(fnType, asm, "", true, false, 0)
+	return c.builder.CreateCall(target, nil, ""), nil
+}
+
+// This is a compiler builtin, which allows assembly to be called in a flexible
+// way.
+//
+//     func AsmFull(asm string, regs map[string]interface{})
+//
+// The asm parameter must be a constant string. The regs parameter must be
+// provided immediately. For example:
+//
+//     arm.AsmFull(
+//         "str {value}, {result}",
+//         map[string]interface{}{
+//             "value":  1
+//             "result": &dest,
+//         })
+func (c *Compiler) emitAsmFull(frame *Frame, instr *ssa.CallCommon) (llvm.Value, error) {
+	asmString := constant.StringVal(instr.Args[0].(*ssa.Const).Value)
+	registers := map[string]llvm.Value{}
+	registerMap := instr.Args[1].(*ssa.MakeMap)
+	for _, r := range *registerMap.Referrers() {
+		switch r := r.(type) {
+		case *ssa.DebugRef:
+			// ignore
+		case *ssa.MapUpdate:
+			if r.Block() != registerMap.Block() {
+				return llvm.Value{}, c.makeError(instr.Pos(), "register value map must be created in the same basic block")
+			}
+			key := constant.StringVal(r.Key.(*ssa.Const).Value)
+			//println("value:", r.Value.(*ssa.MakeInterface).X.String())
+			registers[key] = c.getValue(frame, r.Value.(*ssa.MakeInterface).X)
+		case *ssa.Call:
+			if r.Common() == instr {
+				break
+			}
+		default:
+			return llvm.Value{}, c.makeError(instr.Pos(), "don't know how to handle argument to inline assembly: "+r.String())
+		}
+	}
+	// TODO: handle dollar signs in asm string
+	registerNumbers := map[string]int{}
+	var err error
+	argTypes := []llvm.Type{}
+	args := []llvm.Value{}
+	constraints := []string{}
+	asmString = regexp.MustCompile("\\{[a-zA-Z]+\\}").ReplaceAllStringFunc(asmString, func(s string) string {
+		// TODO: skip strings like {r4} etc. that look like ARM push/pop
+		// instructions.
+		name := s[1 : len(s)-1]
+		if _, ok := registers[name]; !ok {
+			if err == nil {
+				err = c.makeError(instr.Pos(), "unknown register name: "+name)
+			}
+			return s
+		}
+		if _, ok := registerNumbers[name]; !ok {
+			registerNumbers[name] = len(registerNumbers)
+			argTypes = append(argTypes, registers[name].Type())
+			args = append(args, registers[name])
+			switch registers[name].Type().TypeKind() {
+			case llvm.IntegerTypeKind:
+				constraints = append(constraints, "r")
+			case llvm.PointerTypeKind:
+				constraints = append(constraints, "*m")
+			default:
+				err = c.makeError(instr.Pos(), "unknown type in inline assembly for value: "+name)
+				return s
+			}
+		}
+		return fmt.Sprintf("${%v}", registerNumbers[name])
+	})
+	if err != nil {
+		return llvm.Value{}, err
+	}
+	fnType := llvm.FunctionType(c.ctx.VoidType(), argTypes, false)
+	target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0)
+	return c.builder.CreateCall(target, args, ""), nil
+}
+
+// This is a compiler builtin which emits an inline SVCall instruction. It can
+// be one of:
+//
+//     func SVCall0(num uintptr) uintptr
+//     func SVCall1(num uintptr, a1 interface{}) uintptr
+//     func SVCall2(num uintptr, a1, a2 interface{}) uintptr
+//     func SVCall3(num uintptr, a1, a2, a3 interface{}) uintptr
+//     func SVCall4(num uintptr, a1, a2, a3, a4 interface{}) uintptr
+//
+// The num parameter must be a constant. All other parameters may be any scalar
+// value supported by LLVM inline assembly.
+func (c *Compiler) emitSVCall(frame *Frame, args []ssa.Value) (llvm.Value, error) {
+	num, _ := constant.Uint64Val(args[0].(*ssa.Const).Value)
+	llvmArgs := []llvm.Value{}
+	argTypes := []llvm.Type{}
+	asm := "svc #" + strconv.FormatUint(num, 10)
+	constraints := "={r0}"
+	for i, arg := range args[1:] {
+		arg = arg.(*ssa.MakeInterface).X
+		if i == 0 {
+			constraints += ",0"
+		} else {
+			constraints += ",{r" + strconv.Itoa(i) + "}"
+		}
+		llvmValue := c.getValue(frame, arg)
+		llvmArgs = append(llvmArgs, llvmValue)
+		argTypes = append(argTypes, llvmValue.Type())
+	}
+	// Implement the ARM calling convention by marking r1-r3 as
+	// clobbered. r0 is used as an output register so doesn't have to be
+	// marked as clobbered.
+	constraints += ",~{r1},~{r2},~{r3}"
+	fnType := llvm.FunctionType(c.uintptrType, argTypes, false)
+	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0)
+	return c.builder.CreateCall(target, llvmArgs, ""), nil
+}

compiler/interface-lowering.go

@@ -4,7 +4,6 @@ package compiler
 // form, optimizing them in the process.
 //
 // During SSA construction, the following pseudo-calls are created:
-//     runtime.makeInterface(typecode, methodSet)
 //     runtime.typeAssert(typecode, assertedType)
 //     runtime.interfaceImplements(typecode, interfaceMethodSet)
 //     runtime.interfaceMethod(typecode, interfaceMethodSet, signature)
@@ -14,16 +13,13 @@ package compiler
 //
 // This pass lowers the above functions to their final form:
 //
-// makeInterface:
-//     Replaced with a constant typecode.
-//
 // typeAssert:
 //     Replaced with an icmp instruction so it can be directly used in a type
 //     switch. This is very easy to optimize for LLVM: it will often translate a
 //     type switch into a regular switch statement.
 //     When this type assert is not possible (the type is never used in an
-//     interface with makeInterface), this call is replaced with a constant
-//     false to optimize the type assert away completely.
+//     interface), this call is replaced with a constant false to optimize the
+//     type assert away completely.
 //
 // interfaceImplements:
 //     This call is translated into a call that checks whether the underlying
@@ -166,25 +162,36 @@ func (c *Compiler) LowerInterfaces() {
 
 // run runs the pass itself.
 func (p *lowerInterfacesPass) run() {
-	// Count per type how often it is put in an interface. Also, collect all
-	// methods this type has (if it is named).
-	makeInterface := p.mod.NamedFunction("runtime.makeInterface")
-	makeInterfaceUses := getUses(makeInterface)
-	for _, use := range makeInterfaceUses {
-		typecode := use.Operand(0)
-		name := typecode.Name()
-		if t, ok := p.types[name]; !ok {
-			// This is the first time this type has been seen, add it to the
-			// list of types.
-			t = p.addType(typecode)
-			p.addTypeMethods(t, use.Operand(1))
-		} else {
-			p.addTypeMethods(t, use.Operand(1))
-		}
+	// Collect all type codes.
+	typecodeIDPtr := llvm.PointerType(p.mod.GetTypeByName("runtime.typecodeID"), 0)
+	typeInInterfacePtr := llvm.PointerType(p.mod.GetTypeByName("runtime.typeInInterface"), 0)
+	var typesInInterfaces []llvm.Value
+	for global := p.mod.FirstGlobal(); !global.IsNil(); global = llvm.NextGlobal(global) {
+		switch global.Type() {
+		case typecodeIDPtr:
+			// Retrieve Go type information based on an opaque global variable.
+			// Only the name of the global is relevant, the object itself is
+			// discarded afterwards.
+			name := global.Name()
+			t := &typeInfo{
+				name:     name,
+				typecode: global,
+			}
+			p.types[name] = t
+		case typeInInterfacePtr:
+			// Count per type how often it is put in an interface. Also, collect
+			// all methods this type has (if it is named).
+			typesInInterfaces = append(typesInInterfaces, global)
+			initializer := global.Initializer()
+			typecode := llvm.ConstExtractValue(initializer, []uint32{0})
+			methodSet := llvm.ConstExtractValue(initializer, []uint32{1})
+			t := p.types[typecode.Name()]
+			p.addTypeMethods(t, methodSet)
 
-		// Count the number of MakeInterface instructions, for sorting the
-		// typecodes later.
-		p.types[name].countMakeInterfaces++
+			// Count the number of MakeInterface instructions, for sorting the
+			// typecodes later.
+			t.countMakeInterfaces += len(getUses(global))
+		}
 	}
 
 	// Count per type how often it is type asserted on (e.g. in a switch
@@ -194,9 +201,6 @@ func (p *lowerInterfacesPass) run() {
 	for _, use := range typeAssertUses {
 		typecode := use.Operand(1)
 		name := typecode.Name()
-		if _, ok := p.types[name]; !ok {
-			p.addType(typecode)
-		}
 		p.types[name].countTypeAsserts++
 	}
 
@@ -286,16 +290,6 @@ func (p *lowerInterfacesPass) run() {
 		typecode := use.Operand(0)
 		signature := p.signatures[use.Operand(2).Name()]
 
-		// If the interface was created in the same function, we can insert a
-		// direct call. This may not happen often but it is an easy
-		// optimization so let's do it anyway.
-		if !typecode.IsACallInst().IsNil() && typecode.CalledValue() == makeInterface {
-			name := typecode.Operand(0).Name()
-			typ := p.types[name]
-			p.replaceInvokeWithCall(use, typ, signature)
-			continue
-		}
-
 		methodSet := use.Operand(1).Operand(0) // global variable
 		itf := p.interfaces[methodSet.Name()]
 		if len(itf.types) == 0 {
@@ -356,20 +350,6 @@ func (p *lowerInterfacesPass) run() {
 	// types, if possible.
 	for _, use := range interfaceImplementsUses {
 		actualType := use.Operand(0)
-		if !actualType.IsACallInst().IsNil() && actualType.CalledValue() == makeInterface {
-			// Type assert is in the same function that creates the interface
-			// value. This means the underlying type is already known so match
-			// on that.
-			// This may not happen often but it is an easy optimization.
-			name := actualType.Operand(0).Name()
-			typ := p.types[name]
-			p.builder.SetInsertPointBefore(use)
-			assertedType := p.builder.CreatePtrToInt(typ.typecode, p.uintptrType, "typeassert.typecode")
-			commaOk := p.builder.CreateICmp(llvm.IntEQ, assertedType, actualType, "typeassert.ok")
-			use.ReplaceAllUsesWith(commaOk)
-			use.EraseFromParentAsInstruction()
-			continue
-		}
 
 		methodSet := use.Operand(1).Operand(0) // global variable
 		itf := p.interfaces[methodSet.Name()]
@@ -416,12 +396,14 @@ func (p *lowerInterfacesPass) run() {
 	// Assign a type code for each type.
 	p.assignTypeCodes(typeSlice)
 
-	// Replace each call to runtime.makeInterface with the constant type code.
-	for _, use := range makeInterfaceUses {
-		global := use.Operand(0)
-		t := p.types[global.Name()]
-		use.ReplaceAllUsesWith(llvm.ConstPtrToInt(t.typecode, p.uintptrType))
-		use.EraseFromParentAsInstruction()
+	// Replace each use of a runtime.typeInInterface with the constant type
+	// code.
+	for _, global := range typesInInterfaces {
+		for _, use := range getUses(global) {
+			t := p.types[llvm.ConstExtractValue(global.Initializer(), []uint32{0}).Name()]
+			typecode := llvm.ConstInt(p.uintptrType, t.num, false)
+			use.ReplaceAllUsesWith(typecode)
+		}
 	}
 
 	// Replace each type assert with an actual type comparison or (if the type
@@ -458,12 +440,18 @@ func (p *lowerInterfacesPass) run() {
 	// numbers.
 	for _, typ := range p.types {
 		for _, use := range getUses(typ.typecode) {
-			if use.IsConstant() && use.Opcode() == llvm.PtrToInt {
+			if !use.IsAConstantExpr().IsNil() && use.Opcode() == llvm.PtrToInt {
 				use.ReplaceAllUsesWith(llvm.ConstInt(p.uintptrType, typ.num, false))
 			}
 		}
 	}
 
+	// Remove stray runtime.typeInInterface globals. Required for the following
+	// cleanup.
+	for _, global := range typesInInterfaces {
+		global.EraseFromParentAsGlobal()
+	}
+
 	// Remove method sets of types. Unnecessary, but cleans up the IR for
 	// inspection.
 	for _, typ := range p.types {
@@ -474,19 +462,6 @@ func (p *lowerInterfacesPass) run() {
 	}
 }
 
-// addType retrieves Go type information based on a i16 global variable.
-// Only the name of the i16 is relevant, the object itself is const-propagated
-// and discared afterwards.
-func (p *lowerInterfacesPass) addType(typecode llvm.Value) *typeInfo {
-	name := typecode.Name()
-	t := &typeInfo{
-		name:     name,
-		typecode: typecode,
-	}
-	p.types[name] = t
-	return t
-}
-
 // addTypeMethods reads the method set of the given type info struct. It
 // retrieves the signatures and the references to the method functions
 // themselves for later type<->interface matching.
@@ -552,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

@@ -23,43 +23,21 @@ import (
 //
 // 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*")
-		}
-	}
+	itfValue := c.emitPointerPack([]llvm.Value{val})
 	itfTypeCodeGlobal := c.getTypeCode(typ)
 	itfMethodSetGlobal, err := c.getTypeMethodSet(typ)
 	if err != nil {
 		return llvm.Value{}, nil
 	}
-	itfTypeCode := c.createRuntimeCall("makeInterface", []llvm.Value{itfTypeCodeGlobal, itfMethodSetGlobal}, "makeinterface.typecode")
+	itfConcreteTypeGlobal := c.mod.NamedGlobal("typeInInterface:" + itfTypeCodeGlobal.Name())
+	if itfConcreteTypeGlobal.IsNil() {
+		typeInInterface := c.mod.GetTypeByName("runtime.typeInInterface")
+		itfConcreteTypeGlobal = llvm.AddGlobal(c.mod, typeInInterface, "typeInInterface:"+itfTypeCodeGlobal.Name())
+		itfConcreteTypeGlobal.SetInitializer(llvm.ConstNamedStruct(typeInInterface, []llvm.Value{itfTypeCodeGlobal, itfMethodSetGlobal}))
+		itfConcreteTypeGlobal.SetGlobalConstant(true)
+		itfConcreteTypeGlobal.SetLinkage(llvm.PrivateLinkage)
+	}
+	itfTypeCode := c.builder.CreatePtrToInt(itfConcreteTypeGlobal, c.uintptrType, "")
 	itf := llvm.Undef(c.mod.GetTypeByName("runtime._interface"))
 	itf = c.builder.CreateInsertValue(itf, itfTypeCode, 0, "")
 	itf = c.builder.CreateInsertValue(itf, itfValue, 1, "")
@@ -73,7 +51,7 @@ func (c *Compiler) getTypeCode(typ types.Type) llvm.Value {
 	globalName := "type:" + getTypeCodeName(typ)
 	global := c.mod.NamedGlobal(globalName)
 	if global.IsNil() {
-		global = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), globalName)
+		global = llvm.AddGlobal(c.mod, c.mod.GetTypeByName("runtime.typecodeID"), globalName)
 		global.SetGlobalConstant(true)
 	}
 	return global
@@ -162,6 +140,10 @@ func getTypeCodeName(t types.Type) string {
 		return "slice:" + name + getTypeCodeName(t.Elem())
 	case *types.Struct:
 		elems := make([]string, t.NumFields())
+		if t.NumFields() > 2 && t.Field(0).Name() == "C union" {
+			// TODO: report this as a normal error instead of panicking.
+			panic("cgo unions are not allowed in interfaces")
+		}
 		for i := 0; i < t.NumFields(); i++ {
 			elems[i] = getTypeCodeName(t.Field(i).Type())
 		}
@@ -262,19 +244,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{}
@@ -327,71 +299,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.getLLVMType(instr.Method.Type())
-	if err != nil {
-		return llvm.Value{}, nil, err
-	}
-	// getLLVMType() has created a closure type for us, but we don't actually
-	// want a closure type as an interface call can never be a closure call. So
-	// extract the function pointer type from the closure.
-	llvmFnType = llvmFnType.Subtypes()[1]
+	llvmFnType := c.getRawFuncType(instr.Method.Type().(*types.Signature))
 
 	typecode := c.builder.CreateExtractValue(itf, 0, "invoke.typecode")
 	values := []llvm.Value{
@@ -405,11 +341,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.
@@ -417,7 +349,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
@@ -442,10 +374,7 @@ func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) (llvm.Value, error)
 	}
 
 	// 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?
@@ -472,7 +401,7 @@ func (c *Compiler) getInterfaceInvokeWrapper(f *ir.Function) (llvm.Value, error)
 
 // 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
@@ -482,10 +411,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{})
 	}
 
@@ -493,28 +419,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, "")
@@ -523,6 +428,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,17 @@ func getUses(value llvm.Value) []llvm.Value {
 	return uses
 }
 
+// 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,10 +10,7 @@ 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
-	}
+	llvmValueType := c.getLLVMType(valueType)
 	mapValueAlloca := c.builder.CreateAlloca(llvmValueType, "hashmap.value")
 	mapValuePtr := c.builder.CreateBitCast(mapValueAlloca, c.i8ptrType, "hashmap.valueptr")
 	var commaOkValue llvm.Value
@@ -42,7 +39,7 @@ 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 {
+func (c *Compiler) emitMapUpdate(keyType types.Type, m, key, value llvm.Value, pos token.Pos) {
 	valueAlloca := c.builder.CreateAlloca(value.Type(), "hashmap.value")
 	c.builder.CreateStore(value, valueAlloca)
 	valuePtr := c.builder.CreateBitCast(valueAlloca, c.i8ptrType, "hashmap.valueptr")
@@ -51,7 +48,6 @@ func (c *Compiler) emitMapUpdate(keyType types.Type, m, key, value llvm.Value, p
 		// 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")
@@ -59,9 +55,8 @@ func (c *Compiler) emitMapUpdate(keyType types.Type, m, key, value llvm.Value, p
 		keyPtr := c.builder.CreateBitCast(keyAlloca, c.i8ptrType, "hashmap.keyptr")
 		params := []llvm.Value{m, keyPtr, valuePtr}
 		c.createRuntimeCall("hashmapBinarySet", params, "")
-		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())
+		c.addError(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()
@@ -43,6 +47,7 @@ func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) erro
 		c.OptimizeStringToBytes()
 		c.OptimizeAllocs()
 		c.LowerInterfaces()
+		c.LowerFuncValues()
 
 		// After interfaces are lowered, there are many more opportunities for
 		// interprocedural optimizations. To get them to work, function
@@ -53,6 +58,22 @@ func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) erro
 		c.OptimizeAllocs()
 		c.OptimizeStringToBytes()
 
+		// Lower runtime.isnil calls to regular nil comparisons.
+		isnil := c.mod.NamedFunction("runtime.isnil")
+		if !isnil.IsNil() {
+			for _, use := range getUses(isnil) {
+				c.builder.SetInsertPointBefore(use)
+				ptr := use.Operand(0)
+				if !ptr.IsABitCastInst().IsNil() {
+					ptr = ptr.Operand(0)
+				}
+				nilptr := llvm.ConstPointerNull(ptr.Type())
+				icmp := c.builder.CreateICmp(llvm.IntEQ, ptr, nilptr, "")
+				use.ReplaceAllUsesWith(icmp)
+				use.EraseFromParentAsInstruction()
+			}
+		}
+
 		err := c.LowerGoroutines()
 		if err != nil {
 			return err
@@ -60,6 +81,7 @@ func (c *Compiler) Optimize(optLevel, sizeLevel int, inlinerThreshold uint) erro
 	} else {
 		// Must be run at any optimization level.
 		c.LowerInterfaces()
+		c.LowerFuncValues()
 		err := c.LowerGoroutines()
 		if err != nil {
 			return err
@@ -95,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
@@ -231,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)
@@ -266,21 +307,12 @@ 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
 			}
+		} else if use.IsAICmpInst() != nilValue {
+			// Comparing pointers don't let the pointer escape.
+			// This is often a compiler-inserted nil check.
 		} else {
 			// Unknown instruction, might escape.
 			return true

compiler/sizes.go

@@ -63,6 +63,12 @@ func (s *StdSizes) Alignof(T types.Type) int64 {
 
 func (s *StdSizes) Offsetsof(fields []*types.Var) []int64 {
 	offsets := make([]int64, len(fields))
+	if len(fields) > 1 && fields[0].Name() == "C union" {
+		// This struct contains the magic "C union" field which indicates that
+		// this is actually a union from CGo.
+		// All fields in the union start at 0 so return that.
+		return offsets // all fields are still set to 0
+	}
 	var o int64
 	for i, f := range fields {
 		a := s.Alignof(f.Type())
@@ -107,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()
@@ -125,11 +134,38 @@ func (s *StdSizes) Sizeof(T types.Type) int64 {
 			return 0
 		}
 		fields := make([]*types.Var, t.NumFields())
+		maxAlign := int64(1)
 		for i := range fields {
-			fields[i] = t.Field(i)
+			field := t.Field(i)
+			fields[i] = field
+			al := s.Alignof(field.Type())
+			if al > maxAlign {
+				maxAlign = al
+			}
+		}
+		if fields[0].Name() == "C union" {
+			// Magic field that indicates this is a CGo union and not a struct.
+			// The size is the biggest element, aligned to the element with the
+			// biggest alignment. This is not necessarily the same, for example
+			// in the following union:
+			//     union { int32_t l; int16_t s[3] }
+			maxSize := int64(0)
+			for _, field := range fields[1:] {
+				si := s.Sizeof(field.Type())
+				if si > maxSize {
+					maxSize = si
+				}
+			}
+			return align(maxSize, maxAlign)
+		} else {
+			// This is a regular struct.
+			// Pick the size that fits this struct and add some alignment. Some
+			// structs have some extra padding at the end which should also be
+			// taken care of:
+			//     struct { int32 n; byte b }
+			offsets := s.Offsetsof(fields)
+			return align(offsets[n-1]+s.Sizeof(fields[n-1].Type()), maxAlign)
 		}
-		offsets := s.Offsetsof(fields)
-		return offsets[n-1] + s.Sizeof(fields[n-1].Type())
 	case *types.Interface:
 		return s.PtrSize * 2
 	case *types.Pointer:

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/wordpack.go

@@ -0,0 +1,108 @@
+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.builder.CreateAlloca(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), "")
+		return c.builder.CreateLoad(packedAlloc, "")
+	} 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 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.builder.CreateAlloca(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, "")
+	}
+	return values
+}

interp/frame.go

@@ -95,7 +95,7 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 		case !inst.IsALoadInst().IsNil():
 			operand := fr.getLocal(inst.Operand(0)).(*LocalValue)
 			var value llvm.Value
-			if !operand.IsConstant() || inst.IsVolatile() || operand.Underlying.Opcode() == llvm.BitCast {
+			if !operand.IsConstant() || inst.IsVolatile() || (!operand.Underlying.IsAConstantExpr().IsNil() && operand.Underlying.Opcode() == llvm.BitCast) {
 				value = fr.builder.CreateLoad(operand.Value(), inst.Name())
 			} else {
 				value = operand.Load()
@@ -307,9 +307,46 @@ func (fr *frame) evalBasicBlock(bb, incoming llvm.BasicBlock, indent string) (re
 				ret = llvm.ConstInsertValue(ret, retLen, []uint32{1}) // len
 				ret = llvm.ConstInsertValue(ret, retLen, []uint32{2}) // cap
 				fr.locals[inst] = &LocalValue{fr.Eval, ret}
-			case callee.Name() == "runtime.makeInterface":
-				uintptrType := callee.Type().Context().IntType(fr.TargetData.PointerSize() * 8)
-				fr.locals[inst] = &LocalValue{fr.Eval, llvm.ConstPtrToInt(inst.Operand(0), uintptrType)}
+			case callee.Name() == "runtime.interfaceImplements":
+				typecode := fr.getLocal(inst.Operand(0)).(*LocalValue).Underlying
+				interfaceMethodSet := fr.getLocal(inst.Operand(1)).(*LocalValue).Underlying
+				if typecode.IsAConstantExpr().IsNil() || typecode.Opcode() != llvm.PtrToInt {
+					panic("interp: expected typecode to be a ptrtoint")
+				}
+				typecode = typecode.Operand(0)
+				if interfaceMethodSet.IsAConstantExpr().IsNil() || interfaceMethodSet.Opcode() != llvm.GetElementPtr {
+					panic("interp: expected method set in runtime.interfaceImplements to be a constant gep")
+				}
+				interfaceMethodSet = interfaceMethodSet.Operand(0).Initializer()
+				methodSet := llvm.ConstExtractValue(typecode.Initializer(), []uint32{1})
+				if methodSet.IsAConstantExpr().IsNil() || methodSet.Opcode() != llvm.GetElementPtr {
+					panic("interp: expected method set to be a constant gep")
+				}
+				methodSet = methodSet.Operand(0).Initializer()
+
+				// Make a set of all the methods on the concrete type, for
+				// easier checking in the next step.
+				definedMethods := map[string]struct{}{}
+				for i := 0; i < methodSet.Type().ArrayLength(); i++ {
+					methodInfo := llvm.ConstExtractValue(methodSet, []uint32{uint32(i)})
+					name := llvm.ConstExtractValue(methodInfo, []uint32{0}).Name()
+					definedMethods[name] = struct{}{}
+				}
+				// Check whether all interface methods are also in the list
+				// of defined methods calculated above.
+				implements := uint64(1) // i1 true
+				for i := 0; i < interfaceMethodSet.Type().ArrayLength(); i++ {
+					name := llvm.ConstExtractValue(interfaceMethodSet, []uint32{uint32(i)}).Name()
+					if _, ok := definedMethods[name]; !ok {
+						// There is a method on the interface that is not
+						// implemented by the type.
+						implements = 0 // i1 false
+						break
+					}
+				}
+				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 strings.HasPrefix(callee.Name(), "runtime.print") || callee.Name() == "runtime._panic":
 				// This are all print instructions, which necessarily have side
 				// effects but no results.

interp/scan.go

@@ -28,8 +28,13 @@ func (e *Eval) hasSideEffects(fn llvm.Value) *sideEffectResult {
 	case "runtime.alloc":
 		// Cannot be scanned but can be interpreted.
 		return &sideEffectResult{severity: sideEffectNone}
+	case "runtime.nanotime":
+		// Fixed value at compile time.
+		return &sideEffectResult{severity: sideEffectNone}
 	case "runtime._panic":
 		return &sideEffectResult{severity: sideEffectLimited}
+	case "runtime.interfaceImplements":
+		return &sideEffectResult{severity: sideEffectNone}
 	}
 	if e.sideEffectFuncs == nil {
 		e.sideEffectFuncs = make(map[llvm.Value]*sideEffectResult)
@@ -81,11 +86,6 @@ func (e *Eval) hasSideEffects(fn llvm.Value) *sideEffectResult {
 					continue
 				}
 				if child.IsDeclaration() {
-					switch child.Name() {
-					case "runtime.makeInterface":
-						// Can be interpreted so does not have side effects.
-						continue
-					}
 					// External function call. Assume only limited side effects
 					// (no affected globals, etc.).
 					if e.hasLocalSideEffects(dirtyLocals, inst) {

linker-builtin.go

@@ -22,9 +22,9 @@ import "C"
 // Link invokes a linker with the given name and flags.
 //
 // This version uses the built-in linker when trying to use lld.
-func Link(dir, linker string, flags ...string) error {
+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(dir, 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,10 +57,12 @@ func Link(dir, 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
-		cmd.Dir = dir
 		return cmd.Run()
 	}
 }

linker-external.go

@@ -13,10 +13,12 @@ import (
 // Link invokes a linker with the given name and arguments.
 //
 // This version always runs the linker as an external command.
-func Link(dir, linker string, flags ...string) error {
+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
-	cmd.Dir = dir
 	return cmd.Run()
 }

loader/cgo.go

@@ -16,11 +16,14 @@ import (
 // fileInfo holds all Cgo-related information of a given *ast.File.
 type fileInfo struct {
 	*ast.File
-	filename   string
-	functions  map[string]*functionInfo
-	globals    map[string]*globalInfo
-	typedefs   map[string]*typedefInfo
-	importCPos token.Pos
+	*Package
+	filename        string
+	functions       map[string]*functionInfo
+	globals         map[string]*globalInfo
+	typedefs        map[string]*typedefInfo
+	elaboratedTypes map[string]ast.Expr
+	importCPos      token.Pos
+	missingSymbols  map[string]struct{}
 }
 
 // functionInfo stores some information about a Cgo function found by libclang
@@ -60,10 +63,27 @@ var cgoAliases = map[string]string{
 	"C.uintptr_t": "uintptr",
 }
 
+// cgoBuiltinAliases are handled specially because they only exist on the Go
+// side of CGo, not on the CGo (they're prefixed with "_Cgo_" there).
+var cgoBuiltinAliases = 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;
@@ -78,13 +98,22 @@ 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 {
+func (p *Package) processCgo(filename string, f *ast.File, cflags []string) []error {
 	info := &fileInfo{
-		File:      f,
-		filename:  filename,
-		functions: map[string]*functionInfo{},
-		globals:   map[string]*globalInfo{},
-		typedefs:  map[string]*typedefInfo{},
+		File:            f,
+		Package:         p,
+		filename:        filename,
+		functions:       map[string]*functionInfo{},
+		globals:         map[string]*globalInfo{},
+		typedefs:        map[string]*typedefInfo{},
+		elaboratedTypes: map[string]ast.Expr{},
+		missingSymbols:  map[string]struct{}{},
+	}
+
+	// Find all C.* symbols.
+	f = astutil.Apply(f, info.findMissingCGoNames, nil).(*ast.File)
+	for name := range cgoBuiltinAliases {
+		info.missingSymbols["_Cgo_"+name] = struct{}{}
 	}
 
 	// Find `import "C"` statements in the file.
@@ -114,9 +143,10 @@ func (p *Package) processCgo(filename string, f *ast.File, cflags []string) erro
 		// source location.
 		info.importCPos = spec.Path.ValuePos
 
-		err = info.parseFragment(cgoComment+cgoTypes, cflags)
-		if err != nil {
-			return err
+		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.
@@ -139,9 +169,12 @@ func (p *Package) processCgo(filename string, f *ast.File, cflags []string) erro
 	// Forward C types to Go types (like C.uint32_t -> uint32).
 	info.addTypeAliases()
 
-	// Add type declarations for C types, declared using typeef in C.
+	// 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)
 
@@ -212,6 +245,9 @@ func (info *fileInfo) addFuncDecls() {
 //         // ...
 //     )
 func (info *fileInfo) addFuncPtrDecls() {
+	if len(info.functions) == 0 {
+		return
+	}
 	gen := &ast.GenDecl{
 		TokPos: info.importCPos,
 		Tok:    token.VAR,
@@ -260,6 +296,9 @@ func (info *fileInfo) addFuncPtrDecls() {
 //         // ...
 //     )
 func (info *fileInfo) addVarDecls() {
+	if len(info.globals) == 0 {
+		return
+	}
 	gen := &ast.GenDecl{
 		TokPos: info.importCPos,
 		Tok:    token.VAR,
@@ -336,6 +375,9 @@ func (info *fileInfo) addTypeAliases() {
 }
 
 func (info *fileInfo) addTypedefs() {
+	if len(info.typedefs) == 0 {
+		return
+	}
 	gen := &ast.GenDecl{
 		TokPos: info.importCPos,
 		Tok:    token.TYPE,
@@ -348,8 +390,10 @@ func (info *fileInfo) addTypedefs() {
 	for _, name := range names {
 		typedef := info.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).
@@ -367,12 +411,75 @@ func (info *fileInfo) addTypedefs() {
 			},
 			Type: typedef.typeExpr,
 		}
+		if isAlias {
+			typeSpec.Assign = info.importCPos
+		}
 		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() {
+	if len(info.elaboratedTypes) == 0 {
+		return
+	}
+	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." + 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)
+}
+
+// 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 (info *fileInfo) 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 := cgoBuiltinAliases[name]; ok {
+				name = "_Cgo_" + name
+			}
+			info.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

loader/libclang.go

@@ -4,31 +4,78 @@ package loader
 // modification. It does not touch the AST itself.
 
 import (
-	"errors"
+	"fmt"
 	"go/ast"
+	"go/scanner"
 	"go/token"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"unsafe"
 )
 
 /*
-#include <clang-c/Index.h> // if this fails, install libclang-7-dev
+#include <clang-c/Index.h> // if this fails, install libclang-8-dev
 #include <stdlib.h>
+#include <stdint.h>
 
-int tinygo_clang_visitor(CXCursor c, CXCursor parent, CXClientData client_data);
+// 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);
+CXTranslationUnit tinygo_clang_Cursor_getTranslationUnit(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);
 */
 import "C"
 
-var globalFileInfo *fileInfo
+// refMap stores references to types, used for clang_visitChildren.
+var refMap RefMap
 
-func (info *fileInfo) parseFragment(fragment string, cflags []string) error {
-	index := C.clang_createIndex(0, 1)
+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("cgo-fake.c")
+	// 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))
 
@@ -61,104 +108,117 @@ func (info *fileInfo) parseFragment(fragment string, cflags []string) error {
 	}
 	defer C.clang_disposeTranslationUnit(unit)
 
-	if C.clang_getNumDiagnostics(unit) != 0 {
-		return errors.New("cgo: libclang cannot parse fragment")
+	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 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(info.Program.Dir, filename)
+				if err == nil {
+					filename = relpath
+				}
+			}
+			errs = append(errs, &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 errs
 	}
 
-	if globalFileInfo != nil {
-		// There is a race condition here but that doesn't really matter as it
-		// is a sanity check anyway.
-		panic("libclang.go cannot be used concurrently yet")
-	}
-	globalFileInfo = info
-	defer func() {
-		globalFileInfo = nil
-	}()
-
-	cursor := C.clang_getTranslationUnitCursor(unit)
-	C.clang_visitChildren(cursor, (*[0]byte)(unsafe.Pointer(C.tinygo_clang_visitor)), C.CXClientData(uintptr(0)))
+	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_visitor
-func tinygo_clang_visitor(c, parent C.CXCursor, client_data C.CXClientData) C.int {
-	info := globalFileInfo
-	kind := C.clang_getCursorKind(c)
+//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)
+	pos := info.getCursorPosition(c)
 	switch kind {
 	case C.CXCursor_FunctionDecl:
-		name := getString(C.clang_getCursorSpelling(c))
-		cursorType := C.clang_getCursorType(c)
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if _, required := info.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.clang_Cursor_getNumArguments(c))
+		numArgs := int(C.tinygo_clang_Cursor_getNumArguments(c))
 		fn := &functionInfo{}
 		info.functions[name] = fn
 		for i := 0; i < numArgs; i++ {
-			arg := C.clang_Cursor_getArgument(c, C.uint(i))
-			argName := getString(C.clang_getCursorSpelling(arg))
+			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),
+				typeExpr: info.makeASTType(argType, pos),
 			})
 		}
-		resultType := C.clang_getCursorResultType(c)
+		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),
+						Type: info.makeASTType(resultType, pos),
 					},
 				},
 			}
 		}
+	case C.CXCursor_StructDecl:
+		typ := C.tinygo_clang_getCursorType(c)
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if _, required := info.missingSymbols["struct_"+name]; !required {
+			return C.CXChildVisit_Continue
+		}
+		info.makeASTType(typ, pos)
 	case C.CXCursor_TypedefDecl:
-		typedefType := C.clang_getCursorType(c)
+		typedefType := C.tinygo_clang_getCursorType(c)
 		name := getString(C.clang_getTypedefName(typedefType))
-		underlyingType := C.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,
+		if _, required := info.missingSymbols[name]; !required {
+			return C.CXChildVisit_Continue
 		}
+		info.makeASTType(typedefType, pos)
 	case C.CXCursor_VarDecl:
-		name := getString(C.clang_getCursorSpelling(c))
-		cursorType := C.clang_getCursorType(c)
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if _, required := info.missingSymbols[name]; !required {
+			return C.CXChildVisit_Continue
+		}
+		cursorType := C.tinygo_clang_getCursorType(c)
 		info.globals[name] = &globalInfo{
-			typeExpr: info.makeASTType(cursorType),
+			typeExpr: info.makeASTType(cursorType, pos),
 		}
 	}
 	return C.CXChildVisit_Continue
@@ -171,11 +231,48 @@ func getString(clangString C.CXString) (s string) {
 	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 (info *fileInfo) 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 := info.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 := info.fset.AddFile(filename, -1, int(size))
+		f.SetLines(lines)
+		info.tokenFiles[filename] = f
+	}
+	return info.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 (info *fileInfo) makeASTType(typ C.CXType) ast.Expr {
+func (info *fileInfo) 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:
@@ -216,9 +313,33 @@ func (info *fileInfo) makeASTType(typ C.CXType) ast.Expr {
 			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: info.importCPos,
-			X:    info.makeASTType(C.clang_getPointeeType(typ)),
+			Star: pos,
+			X:    info.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: info.makeASTType(C.clang_getElementType(typ), pos),
 		}
 	case C.CXType_FunctionProto:
 		// Be compatible with gc, which uses the *[0]byte type for function
@@ -226,17 +347,151 @@ func (info *fileInfo) makeASTType(typ C.CXType) ast.Expr {
 		// Return type [0]byte because this is a function type, not a pointer to
 		// this function type.
 		return &ast.ArrayType{
-			Lbrack: info.importCPos,
+			Lbrack: pos,
 			Len: &ast.BasicLit{
-				ValuePos: info.importCPos,
+				ValuePos: pos,
 				Kind:     token.INT,
 				Value:    "0",
 			},
 			Elt: &ast.Ident{
-				NamePos: info.importCPos,
+				NamePos: pos,
 				Name:    "byte",
 			},
 		}
+	case C.CXType_Typedef:
+		name := getString(C.clang_getTypedefName(typ))
+		if _, ok := info.typedefs[name]; !ok {
+			info.typedefs[name] = nil // don't recurse
+			c := C.tinygo_clang_getTypeDeclaration(typ)
+			underlyingType := C.tinygo_clang_getTypedefDeclUnderlyingType(c)
+			expr := info.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"
+					}
+				}
+			}
+			info.typedefs[name] = &typedefInfo{
+				typeExpr: expr,
+			}
+		}
+		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 info.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 := info.elaboratedTypes[cgoName]; !ok {
+			info.elaboratedTypes[cgoName] = nil // predeclare (to avoid endless recursion)
+			fieldList := &ast.FieldList{
+				Opening: pos,
+				Closing: pos,
+			}
+			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:
+				info.elaboratedTypes[cgoName] = &ast.StructType{
+					Struct: pos,
+					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: 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...)
+				}
+				info.elaboratedTypes[cgoName] = &ast.StructType{
+					Struct: pos,
+					Fields: fieldList,
+				}
+			default:
+				panic("unreachable")
+			}
+		}
+		return &ast.Ident{
+			NamePos: pos,
+			Name:    "C." + cgoName,
+		}
 	}
 	if typeName == "" {
 		// Fallback, probably incorrect but at least the error points to an odd
@@ -244,7 +499,38 @@ func (info *fileInfo) makeASTType(typ C.CXType) ast.Expr {
 		typeName = "C." + getString(C.clang_getTypeSpelling(typ))
 	}
 	return &ast.Ident{
-		NamePos: info.importCPos,
+		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 := 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, info.getCursorPosition(c)),
+	}
+	field.Names = []*ast.Ident{
+		&ast.Ident{
+			NamePos: info.getCursorPosition(c),
+			Name:    name,
+			Obj: &ast.Object{
+				Kind: ast.Var,
+				Name: name,
+				Decl: field,
+			},
+		},
+	}
+	fieldList.List = append(fieldList.List, field)
+	return C.CXChildVisit_Continue
+}

loader/libclang_config.go

@@ -3,9 +3,9 @@
 package loader
 
 /*
-#cgo linux  CFLAGS: -I/usr/lib/llvm-7/include
+#cgo linux  CFLAGS: -I/usr/lib/llvm-8/include
 #cgo darwin CFLAGS: -I/usr/local/opt/llvm/include
-#cgo linux  LDFLAGS: -L/usr/lib/llvm-7/lib -lclang
+#cgo linux  LDFLAGS: -L/usr/lib/llvm-8/lib -lclang
 #cgo darwin LDFLAGS: -L/usr/local/opt/llvm/lib -lclang -lffi
 */
 import "C"

loader/libclang_stubs.c

@@ -0,0 +1,54 @@
+
+// This file implements some small trampoline functions. The signatures
+// are slightly different from the ones defined in libclang.go, but they
+// should be ABI compatible.
+
+#include <clang-c/Index.h> // if this fails, install libclang-8-dev
+
+CXCursor tinygo_clang_getTranslationUnitCursor(CXTranslationUnit tu) {
+	return clang_getTranslationUnitCursor(tu);
+}
+
+unsigned tinygo_clang_visitChildren(CXCursor parent, CXCursorVisitor visitor, CXClientData client_data) {
+	return clang_visitChildren(parent, visitor, client_data);
+}
+
+CXString tinygo_clang_getCursorSpelling(CXCursor c) {
+	return clang_getCursorSpelling(c);
+}
+
+enum CXCursorKind tinygo_clang_getCursorKind(CXCursor c) {
+	return clang_getCursorKind(c);
+}
+
+CXType tinygo_clang_getCursorType(CXCursor c) {
+	return clang_getCursorType(c);
+}
+
+CXCursor tinygo_clang_getTypeDeclaration(CXType t) {
+	return clang_getTypeDeclaration(t);
+}
+
+CXType tinygo_clang_getTypedefDeclUnderlyingType(CXCursor c) {
+	return clang_getTypedefDeclUnderlyingType(c);
+}
+
+CXType tinygo_clang_getCursorResultType(CXCursor c) {
+	return clang_getCursorResultType(c);
+}
+
+int tinygo_clang_Cursor_getNumArguments(CXCursor c) {
+	return clang_Cursor_getNumArguments(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);
+}
+
+CXTranslationUnit tinygo_clang_Cursor_getTranslationUnit(CXCursor c) {
+	return clang_Cursor_getTranslationUnit(c);
+}

loader/loader.go

@@ -14,23 +14,27 @@ import (
 
 // Program holds all packages and some metadata about the program as a whole.
 type Program struct {
-	Build       *build.Context
-	Packages    map[string]*Package
-	sorted      []*Package
-	fset        *token.FileSet
-	TypeChecker types.Config
-	Dir         string // current working directory (for error reporting)
-	CFlags      []string
+	Build         *build.Context
+	OverlayBuild  *build.Context
+	ShouldOverlay func(path string) bool
+	Packages      map[string]*Package
+	sorted        []*Package
+	fset          *token.FileSet
+	TypeChecker   types.Config
+	Dir           string // current working directory (for error reporting)
+	TINYGOROOT    string // root of the TinyGo installation or root of the source code
+	CFlags        []string
 }
 
 // Package holds a loaded package, its imports, and its parsed files.
 type Package struct {
 	*Program
 	*build.Package
-	Imports   map[string]*Package
-	Importing bool
-	Files     []*ast.File
-	Pkg       *types.Package
+	Imports    map[string]*Package
+	Importing  bool
+	Files      []*ast.File
+	tokenFiles map[string]*token.File
+	Pkg        *types.Package
 	types.Info
 }
 
@@ -42,7 +46,11 @@ func (p *Program) Import(path, srcDir string) (*Package, error) {
 	}
 
 	// Load this package.
-	buildPkg, err := p.Build.Import(path, srcDir, build.ImportComment)
+	ctx := p.Build
+	if p.ShouldOverlay(path) {
+		ctx = p.OverlayBuild
+	}
+	buildPkg, err := ctx.Import(path, srcDir, build.ImportComment)
 	if err != nil {
 		return nil, err
 	}
@@ -99,6 +107,7 @@ func (p *Program) newPackage(pkg *build.Package) *Package {
 			Scopes:     make(map[ast.Node]*types.Scope),
 			Selections: make(map[*ast.SelectorExpr]*types.Selection),
 		},
+		tokenFiles: map[string]*token.File{},
 	}
 }
 
@@ -286,6 +295,16 @@ func (p *Package) parseFiles() ([]*ast.File, error) {
 		}
 		files = append(files, f)
 	}
+	clangIncludes := ""
+	if len(p.CgoFiles) != 0 {
+		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")
+		}
+	}
 	for _, file := range p.CgoFiles {
 		path := filepath.Join(p.Package.Dir, file)
 		f, err := p.parseFile(path, parser.ParseComments)
@@ -293,9 +312,9 @@ func (p *Package) parseFiles() ([]*ast.File, error) {
 			fileErrs = append(fileErrs, err)
 			continue
 		}
-		err = p.processCgo(path, f, append(p.CFlags, "-I"+p.Package.Dir))
-		if err != nil {
-			fileErrs = append(fileErrs, err)
+		errs := p.processCgo(path, f, append(p.CFlags, "-I"+p.Package.Dir, "-I"+clangIncludes))
+		if errs != nil {
+			fileErrs = append(fileErrs, errs...)
 			continue
 		}
 		files = append(files, f)

loader/sync.go

@@ -0,0 +1,46 @@
+package loader
+
+import (
+	"sync"
+	"unsafe"
+)
+
+// #include <stdlib.h>
+import "C"
+
+// 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 {
+	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 {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+	if m.refs == nil {
+		m.refs = make(map[unsafe.Pointer]interface{}, 1)
+	}
+	ref := C.malloc(1)
+	m.refs[ref] = v
+	return ref
+}
+
+// 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{} {
+	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) {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+	delete(m.refs, ref)
+	C.free(ref)
+}

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,39 @@ 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")
+	}
 	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,
+		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:     spec.BuildTags,
 	}
 	c, err := compiler.NewCompiler(pkgName, compilerConfig)
 	if err != nil {
@@ -75,12 +102,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 +221,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)
+		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 +246,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,7 +259,7 @@ func Compile(pkgName, outpath string, spec *TargetSpec, config *BuildConfig, act
 		}
 
 		// Link the object files together.
-		err = Link(sourceDir(), spec.Linker, ldflags...)
+		err = Link(spec.Linker, ldflags...)
 		if err != nil {
 			return &commandError{"failed to link", executable, err}
 		}
@@ -492,6 +523,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)
 		}
@@ -503,6 +538,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")
@@ -523,13 +559,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 != "" {
@@ -540,6 +577,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/examples/colorlamp/colorlamp.go

@@ -1,79 +0,0 @@
-// This program runs on an Arduino that has the following four devices connected:
-// - Button connected to D2
-// - Rotary analog dial connected to A0
-// - RGB LED connected to D3, D5, and D6 used as PWM pins
-// - BlinkM I2C RGB LED
-//
-// Pushing the button switches which color is selected.
-// Rotating the dial changes the value for the currently selected color.
-// Changing the color value updates the color displayed on both the
-// PWM-controlled RGB LED and the I2C-controlled BlinkM.
-package main
-
-import (
-	"machine"
-	"time"
-)
-
-const (
-	buttonPin = 2
-	redPin    = 3
-	greenPin  = 5
-	bluePin   = 6
-
-	red   = 0
-	green = 1
-	blue  = 2
-)
-
-func main() {
-	machine.InitADC()
-	machine.InitPWM()
-	machine.I2C0.Configure(machine.I2CConfig{})
-
-	// Init BlinkM
-	machine.I2C0.WriteTo(0x09, []byte("o"))
-
-	button := machine.GPIO{buttonPin}
-	button.Configure(machine.GPIOConfig{Mode: machine.GPIO_INPUT})
-
-	dial := machine.ADC{machine.ADC0}
-	dial.Configure()
-
-	redLED := machine.PWM{redPin}
-	redLED.Configure()
-
-	greenLED := machine.PWM{greenPin}
-	greenLED.Configure()
-
-	blueLED := machine.PWM{bluePin}
-	blueLED.Configure()
-
-	selectedColor := red
-	colors := []uint16{0, 0, 0}
-
-	for {
-		// If we pushed the button, switch active color.
-		if !button.Get() {
-			if selectedColor == blue {
-				selectedColor = red
-			} else {
-				selectedColor++
-			}
-		}
-
-		// Change the intensity for the currently selected color based on the dial setting.
-		colors[selectedColor] = (dial.Get())
-
-		// Update the RGB LED.
-		redLED.Set(colors[red])
-		greenLED.Set(colors[green])
-		blueLED.Set(colors[blue])
-
-		// Update the BlinkM.
-		machine.I2C0.WriteTo(0x09, []byte("n"))
-		machine.I2C0.WriteTo(0x09, []byte{byte(colors[red] >> 8), byte(colors[green] >> 8), byte(colors[blue] >> 8)})
-
-		time.Sleep(time.Millisecond * 100)
-	}
-}

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

@@ -0,0 +1,24 @@
+// blink program for the BBC micro:bit
+package main
+
+import (
+	"machine"
+	"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() {
+	ledrow := machine.GPIO{machine.LED_ROW_1}
+	ledrow.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	ledcol := machine.GPIO{machine.LED_COL_1}
+	ledcol.Configure(machine.GPIOConfig{Mode: machine.GPIO_OUTPUT})
+	ledcol.Low()
+	for {
+		ledrow.Low()
+		time.Sleep(time.Millisecond * 500)
+
+		ledrow.High()
+		time.Sleep(time.Millisecond * 500)
+	}
+}

src/examples/wasm/.gitignore

@@ -0,0 +1 @@
+html/*

src/examples/wasm/Makefile

@@ -0,0 +1,15 @@
+export: clean wasm_exec
+	tinygo build -o ./html/wasm.wasm -target wasm ./export/wasm.go
+	cp ./export/wasm.js ./html/
+	cp ./export/index.html ./html/
+
+main: clean wasm_exec
+	tinygo build -o ./html/wasm.wasm -target wasm ./main/main.go
+	cp ./main/index.html ./html/
+
+wasm_exec:
+	cp ../../../targets/wasm_exec.js ./html/
+
+clean:
+	rm -rf ./html
+	mkdir ./html

src/examples/wasm/README.md

@@ -0,0 +1,131 @@
+# TinyGo WebAssembly examples
+
+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.
+1. Defining and executing a `func main()`. This is similar to how the Go
+standard library implementation works. See [the main folder](./main) for an
+example of this.
+
+## Building
+
+Build using the `tinygo` compiler:
+
+```bash
+$ tinygo build -o ./wasm.wasm -target wasm ./main/main.go
+```
+
+This creates a `wasm.wasm` file, which we can load in JavaScript and execute in
+a browser.
+
+This examples folder contains two examples that can be built using `make`:
+
+```bash
+$ make export
+```
+
+```bash
+$ make main
+```
+
+## Running
+
+Start the local web server:
+
+```bash
+$ go run main.go
+Serving ./html on http://localhost:8080
+```
+
+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 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
+`WebAssembly.instantiate` in some browsers:
+
+```js
+const go = new Go(); // Defined in wasm_exec.js
+const WASM_URL = 'wasm.wasm';
+
+var wasm;
+
+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);
+		})
+	)
+}
+```
+
+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 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
+
+import (
+	"log"
+	"net/http"
+	"strings"
+)
+
+const dir = "./html"
+
+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.
+
+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/export/index.html

@@ -0,0 +1,20 @@
+<!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="2" /> + <input type="number" id="b" value="2" /> = <input type="number"
+		id="result" readonly />
+</body>
+
+</html>

src/examples/wasm/export/wasm.go

@@ -16,10 +16,10 @@ func add(a, b int) int {
 //go:export update
 func update() {
 	document := js.Global().Get("document")
-	a_str := document.Call("getElementById", "a").Get("value").String()
-	b_str := document.Call("getElementById", "b").Get("value").String()
-	a, _ := strconv.Atoi(a_str)
-	b, _ := strconv.Atoi(b_str)
-	result := a + b
+	aStr := document.Call("getElementById", "a").Get("value").String()
+	bStr := document.Call("getElementById", "b").Get("value").String()
+	a, _ := strconv.Atoi(aStr)
+	b, _ := strconv.Atoi(bStr)
+	result := add(a, b)
 	document.Call("getElementById", "result").Set("value", result)
 }

src/examples/wasm/export/wasm.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const WASM_URL = '../../../wasm.wasm';
+const WASM_URL = 'wasm.wasm';
 
 var wasm;
 
@@ -14,7 +14,7 @@ function init() {
 
   const go = new Go();
   if ('instantiateStreaming' in WebAssembly) {
-    WebAssembly.instantiateStreaming(fetch(WASM_URL), go.importObject).then(function(obj) {
+    WebAssembly.instantiateStreaming(fetch(WASM_URL), go.importObject).then(function (obj) {
       wasm = obj.instance;
       go.run(wasm);
       updateResult();
@@ -23,7 +23,7 @@ function init() {
     fetch(WASM_URL).then(resp =>
       resp.arrayBuffer()
     ).then(bytes =>
-      WebAssembly.instantiate(bytes, go.importObject).then(function(obj) {
+      WebAssembly.instantiate(bytes, go.importObject).then(function (obj) {
         wasm = obj.instance;
         go.run(wasm);
         updateResult();

src/examples/wasm/main/README.md

@@ -0,0 +1,8 @@
+# WebAssembly main execution example
+
+A simple hello world that prints to the browser console.
+
+## License
+
+Note that `index.html` is copied almost verbatim from the Go 1.12 source at
+`$GOROOT/misc/wasm/wasm_exec.html`. Its license applies to this file.

src/examples/wasm/main/index.html

@@ -0,0 +1,49 @@
+<!doctype html>
+<!--
+Copyright 2018 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.
+-->
+<html>
+
+<head>
+	<meta charset="utf-8">
+	<title>Go wasm</title>
+</head>
+
+<body>
+	<!--
+	Add the following polyfill for Microsoft Edge 17/18 support:
+	<script src="https://cdn.jsdelivr.net/npm/text-encoding@0.7.0/lib/encoding.min.js"></script>
+	(see https://caniuse.com/#feat=textencoder)
+	-->
+	<script src="wasm_exec.js"></script>
+	<script>
+		if (!WebAssembly.instantiateStreaming) { // polyfill
+			WebAssembly.instantiateStreaming = async (resp, importObject) => {
+				const source = await (await resp).arrayBuffer();
+				return await WebAssembly.instantiate(source, importObject);
+			};
+		}
+
+		const go = new Go();
+		let mod, inst;
+		WebAssembly.instantiateStreaming(fetch("wasm.wasm"), go.importObject).then((result) => {
+			mod = result.module;
+			inst = result.instance;
+			document.getElementById("runButton").disabled = false;
+		}).catch((err) => {
+			console.error(err);
+		});
+
+		async function run() {
+			console.clear();
+			await go.run(inst);
+			inst = await WebAssembly.instantiate(mod, go.importObject); // reset instance
+		}
+	</script>
+
+	<button onClick="run();" id="runButton" disabled>Run</button>
+</body>
+
+</html>

src/examples/wasm/main/main.go

@@ -0,0 +1,5 @@
+package main
+
+func main() {
+	println("Hello world!")
+}

src/examples/wasm/server.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"strings"
+)
+
+const dir = "./html"
+
+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/examples/wasm/wasm.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-
-<html>
-	<head>
-		<meta charset="utf-8"/>
-		<title>Go WebAssembly</title>
-		<meta name="viewport" content="width=device-width, initial-scale=1"/>
-		<script src="../../../targets/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="2"/> + <input type="number" id="b" value="2"/> = <input type="number" id="result" readonly/>
-	</body>
-</html>

src/machine/board_circuitplay_express.go

@@ -76,8 +76,16 @@ const (
 
 // I2C on the Circuit Playground Express.
 var (
-	I2C0 = I2C{Bus: sam.SERCOM5_I2CM} // external device
-	I2C1 = I2C{Bus: sam.SERCOM1_I2CM} // internal device
+	// external device
+	I2C0 = I2C{Bus: sam.SERCOM5_I2CM,
+		SDA:     SDA_PIN,
+		SCL:     SCL_PIN,
+		PinMode: GPIO_SERCOM}
+	// internal device
+	I2C1 = I2C{Bus: sam.SERCOM1_I2CM,
+		SDA:     SDA1_PIN,
+		SCL:     SCL1_PIN,
+		PinMode: GPIO_SERCOM_ALT}
 )
 
 // SPI pins (internal flash)

src/machine/board_itsybitsy-m0.go

@@ -44,8 +44,8 @@ const (
 
 // UART1 pins
 const (
-	UART_TX_PIN = D1
-	UART_RX_PIN = D0
+	UART_TX_PIN = D10
+	UART_RX_PIN = D11
 )
 
 // I2C pins
@@ -56,7 +56,10 @@ const (
 
 // I2C on the ItsyBitsy M0.
 var (
-	I2C0 = I2C{Bus: sam.SERCOM3_I2CM}
+	I2C0 = I2C{Bus: sam.SERCOM3_I2CM,
+		SDA:     SDA_PIN,
+		SCL:     SCL_PIN,
+		PinMode: GPIO_SERCOM}
 )
 
 // SPI pins

src/machine/board_microbit.go

@@ -2,11 +2,6 @@
 
 package machine
 
-import (
-	"device/nrf"
-	"errors"
-)
-
 // The micro:bit does not have a 32kHz crystal on board.
 const HasLowFrequencyCrystal = false
 
@@ -79,65 +74,3 @@ const (
 	LED_ROW_2 = 14
 	LED_ROW_3 = 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_stm32f4disco.go

@@ -0,0 +1,112 @@
+// +build stm32,stm32f4disco
+
+package machine
+
+const (
+	PA0  = portA + 0
+	PA1  = portA + 1
+	PA2  = portA + 2
+	PA3  = portA + 3
+	PA4  = portA + 4
+	PA5  = portA + 5
+	PA6  = portA + 6
+	PA7  = portA + 7
+	PA8  = portA + 8
+	PA9  = portA + 9
+	PA10 = portA + 10
+	PA11 = portA + 11
+	PA12 = portA + 12
+	PA13 = portA + 13
+	PA14 = portA + 14
+	PA15 = portA + 15
+
+	PB0  = portB + 0
+	PB1  = portB + 1
+	PB2  = portB + 2
+	PB3  = portB + 3
+	PB4  = portB + 4
+	PB5  = portB + 5
+	PB6  = portB + 6
+	PB7  = portB + 7
+	PB8  = portB + 8
+	PB9  = portB + 9
+	PB10 = portB + 10
+	PB11 = portB + 11
+	PB12 = portB + 12
+	PB13 = portB + 13
+	PB14 = portB + 14
+	PB15 = portB + 15
+
+	PC0  = portC + 0
+	PC1  = portC + 1
+	PC2  = portC + 2
+	PC3  = portC + 3
+	PC4  = portC + 4
+	PC5  = portC + 5
+	PC6  = portC + 6
+	PC7  = portC + 7
+	PC8  = portC + 8
+	PC9  = portC + 9
+	PC10 = portC + 10
+	PC11 = portC + 11
+	PC12 = portC + 12
+	PC13 = portC + 13
+	PC14 = portC + 14
+	PC15 = portC + 15
+
+	PD0  = portD + 0
+	PD1  = portD + 1
+	PD2  = portD + 2
+	PD3  = portD + 3
+	PD4  = portD + 4
+	PD5  = portD + 5
+	PD6  = portD + 6
+	PD7  = portD + 7
+	PD8  = portD + 8
+	PD9  = portD + 9
+	PD10 = portD + 10
+	PD11 = portD + 11
+	PD12 = portD + 12
+	PD13 = portD + 13
+	PD14 = portD + 14
+	PD15 = portD + 15
+
+	PE0  = portE + 0
+	PE1  = portE + 1
+	PE2  = portE + 2
+	PE3  = portE + 3
+	PE4  = portE + 4
+	PE5  = portE + 5
+	PE6  = portE + 6
+	PE7  = portE + 7
+	PE8  = portE + 8
+	PE9  = portE + 9
+	PE10 = portE + 10
+	PE11 = portE + 11
+	PE12 = portE + 12
+	PE13 = portE + 13
+	PE14 = portE + 14
+	PE15 = portE + 15
+
+	PH0 = portH + 0
+	PH1 = portH + 1
+)
+
+const (
+	LED         = LED_BUILTIN
+	LED1        = LED_GREEN
+	LED2        = LED_ORANGE
+	LED3        = LED_RED
+	LED4        = LED_BLUE
+	LED_BUILTIN = LED_GREEN
+	LED_GREEN   = PD12
+	LED_ORANGE  = PD13
+	LED_RED     = PD14
+	LED_BLUE    = PD15
+)
+
+// UART pins
+const (
+	UART_TX_PIN = PA2
+	UART_RX_PIN = PA3
+)

src/machine/machine_atsamd21.go

@@ -343,6 +343,12 @@ func (a ADC) Get() uint16 {
 	sam.ADC.INPUTCTRL |= sam.RegValue(ch << sam.ADC_INPUTCTRL_MUXPOS_Pos)
 	waitADCSync()
 
+	// Select internal ground for ADC input
+	sam.ADC.INPUTCTRL &^= sam.ADC_INPUTCTRL_MUXNEG_Msk
+	waitADCSync()
+	sam.ADC.INPUTCTRL |= sam.RegValue(sam.ADC_INPUTCTRL_MUXNEG_GND << sam.ADC_INPUTCTRL_MUXNEG_Pos)
+	waitADCSync()
+
 	// Enable ADC
 	sam.ADC.CTRLA |= sam.ADC_CTRLA_ENABLE
 	waitADCSync()
@@ -368,7 +374,7 @@ func (a ADC) Get() uint16 {
 	sam.ADC.CTRLA &^= sam.ADC_CTRLA_ENABLE
 	waitADCSync()
 
-	return uint16(val)
+	return uint16(val) << 4 // scales from 12 to 16-bit result
 }
 
 func (a ADC) getADCChannel() uint8 {
@@ -416,7 +422,7 @@ var (
 	UART0 = USBCDC{Buffer: NewRingBuffer()}
 
 	// The first hardware serial port on the SAMD21. Uses the SERCOM0 interface.
-	UART1 = UART{Bus: sam.SERCOM0_USART, Buffer: NewRingBuffer()}
+	UART1 = UART{Bus: sam.SERCOM1_USART, Buffer: NewRingBuffer()}
 )
 
 const (
@@ -453,26 +459,26 @@ func (uart UART) Configure(config UARTConfig) {
 	// determine pads
 	var txpad, rxpad int
 	switch config.TX {
-	case UART_TX_PIN:
+	case PA10:
 		txpad = sercomTXPad2
-	case D10:
+	case PA18:
 		txpad = sercomTXPad2
-	case D11:
+	case PA16:
 		txpad = sercomTXPad0
 	default:
 		panic("Invalid TX pin for UART")
 	}
 
 	switch config.RX {
-	case UART_RX_PIN:
+	case PA11:
 		rxpad = sercomRXPad3
-	case D10:
+	case PA18:
 		rxpad = sercomRXPad2
-	case D11:
+	case PA16:
 		rxpad = sercomRXPad0
-	case D12:
+	case PA19:
 		rxpad = sercomRXPad3
-	case D13:
+	case PA17:
 		rxpad = sercomRXPad1
 	default:
 		panic("Invalid RX pin for UART")
@@ -531,11 +537,11 @@ func (uart UART) Configure(config UARTConfig) {
 	uart.Bus.INTENSET = sam.SERCOM_USART_INTENSET_RXC
 
 	// Enable RX IRQ.
-	if config.TX == UART_TX_PIN {
+	if config.TX == PA10 {
 		// UART0
 		arm.EnableIRQ(sam.IRQ_SERCOM0)
 	} else {
-		// UART1
+		// UART1 which is the normal default, since UART0 is used for USBCDC.
 		arm.EnableIRQ(sam.IRQ_SERCOM1)
 	}
 }
@@ -563,7 +569,7 @@ func (uart UART) WriteByte(c byte) error {
 	return nil
 }
 
-//go:export SERCOM0_IRQHandler
+//go:export SERCOM1_IRQHandler
 func handleUART1() {
 	// should reset IRQ
 	UART1.Receive(byte((UART1.Bus.DATA & 0xFF)))
@@ -572,7 +578,10 @@ func handleUART1() {
 
 // I2C on the SAMD21.
 type I2C struct {
-	Bus *sam.SERCOM_I2CM_Type
+	Bus     *sam.SERCOM_I2CM_Type
+	SCL     uint8
+	SDA     uint8
+	PinMode GPIOMode
 }
 
 // I2CConfig is used to store config info for I2C.
@@ -608,7 +617,7 @@ func (i2c I2C) Configure(config I2CConfig) {
 		config.Frequency = TWI_FREQ_100KHZ
 	}
 
-	// reset SERCOM3
+	// reset SERCOM
 	i2c.Bus.CTRLA |= sam.SERCOM_I2CM_CTRLA_SWRST
 	for (i2c.Bus.CTRLA&sam.SERCOM_I2CM_CTRLA_SWRST) > 0 ||
 		(i2c.Bus.SYNCBUSY&sam.SERCOM_I2CM_SYNCBUSY_SWRST) > 0 {
@@ -632,8 +641,8 @@ func (i2c I2C) Configure(config I2CConfig) {
 	}
 
 	// enable pins
-	GPIO{SDA_PIN}.Configure(GPIOConfig{Mode: GPIO_SERCOM})
-	GPIO{SCL_PIN}.Configure(GPIOConfig{Mode: GPIO_SERCOM})
+	GPIO{i2c.SDA}.Configure(GPIOConfig{Mode: i2c.PinMode})
+	GPIO{i2c.SCL}.Configure(GPIOConfig{Mode: i2c.PinMode})
 }
 
 // SetBaudRate sets the communication speed for the I2C.

src/machine/machine_dummy.go

@@ -12,29 +12,77 @@ const (
 )
 
 // Fake LED numbers, for testing.
-const (
-	LED  = LED1
-	LED1 = 0
-	LED2 = 0
-	LED3 = 0
-	LED4 = 0
+var (
+	LED  uint8 = LED1
+	LED1 uint8 = 0
+	LED2 uint8 = 0
+	LED3 uint8 = 0
+	LED4 uint8 = 0
 )
 
 // Fake button numbers, for testing.
-const (
-	BUTTON  = BUTTON1
-	BUTTON1 = 0
-	BUTTON2 = 0
-	BUTTON3 = 0
-	BUTTON4 = 0
+var (
+	BUTTON  uint8 = BUTTON1
+	BUTTON1 uint8 = 5
+	BUTTON2 uint8 = 6
+	BUTTON3 uint8 = 7
+	BUTTON4 uint8 = 8
+)
+
+// Fake SPI interfaces, for testing.
+var (
+	SPI0 = SPI{0}
+)
+
+var (
+	GPIOConfigure func(pin uint8, config GPIOConfig)
+	GPIOSet       func(pin uint8, value bool)
+	GPIOGet       func(pin uint8) bool
+	SPIConfigure  func(bus uint8, sck uint8, mosi uint8, miso uint8)
+	SPITransfer   func(bus uint8, w uint8) uint8
 )
 
 func (p GPIO) Configure(config GPIOConfig) {
+	if GPIOConfigure != nil {
+		GPIOConfigure(p.Pin, config)
+	}
 }
 
 func (p GPIO) Set(value bool) {
+	if GPIOSet != nil {
+		GPIOSet(p.Pin, value)
+	}
 }
 
 func (p GPIO) Get() bool {
+	if GPIOGet != nil {
+		return GPIOGet(p.Pin)
+	}
 	return false
 }
+
+type SPI struct {
+	Bus uint8
+}
+
+type SPIConfig struct {
+	Frequency uint32
+	SCK       uint8
+	MOSI      uint8
+	MISO      uint8
+	Mode      uint8
+}
+
+func (spi SPI) Configure(config SPIConfig) {
+	if SPIConfigure != nil {
+		SPIConfigure(spi.Bus, config.SCK, config.MOSI, config.MISO)
+	}
+}
+
+// Transfer writes/reads a single byte using the SPI interface.
+func (spi SPI) Transfer(w byte) (byte, error) {
+	if SPITransfer != nil {
+		return SPITransfer(spi.Bus, w), nil
+	}
+	return 0, nil
+}

src/machine/machine_stm32.go

@@ -14,4 +14,5 @@ const (
 	portE
 	portF
 	portG
+	portH
 )

src/machine/machine_stm32f407.go

@@ -0,0 +1,220 @@
+// +build stm32,stm32f407
+
+package machine
+
+// Peripheral abstraction layer for the stm32.
+
+import (
+	"device/arm"
+	"device/stm32"
+)
+
+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
+
+	// for UART
+	GPIO_UART_TX = 4
+	GPIO_UART_RX = 5
+
+	//GPIOx_MODER
+	GPIO_MODE_INPUT          = 0
+	GPIO_MODE_GENERAL_OUTPUT = 1
+	GPIO_MODE_ALTERNABTIVE   = 2
+	GPIO_MODE_ANALOG         = 3
+
+	//GPIOx_OTYPER
+	GPIO_OUTPUT_MODE_PUSH_PULL  = 0
+	GPIO_OUTPUT_MODE_OPEN_DRAIN = 1
+
+	// GPIOx_OSPEEDR
+	GPIO_SPEED_LOW     = 0
+	GPIO_SPEED_MID     = 1
+	GPIO_SPEED_HI      = 2
+	GPIO_SPEED_VERY_HI = 3
+
+	// GPIOx_PUPDR
+	GPIO_FLOATING  = 0
+	GPIO_PULL_UP   = 1
+	GPIO_PULL_DOWN = 2
+)
+
+func (p GPIO) getPort() *stm32.GPIO_Type {
+	switch p.Pin / 16 {
+	case 0:
+		return stm32.GPIOA
+	case 1:
+		return stm32.GPIOB
+	case 2:
+		return stm32.GPIOC
+	case 3:
+		return stm32.GPIOD
+	case 4:
+		return stm32.GPIOE
+	case 5:
+		return stm32.GPIOF
+	case 6:
+		return stm32.GPIOG
+	case 7:
+		return stm32.GPIOH
+	case 8:
+		return stm32.GPIOI
+	default:
+		panic("machine: unknown port")
+	}
+}
+
+// enableClock enables the clock for this desired GPIO port.
+func (p GPIO) enableClock() {
+	switch p.Pin / 16 {
+	case 0:
+		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOAEN
+	case 1:
+		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOBEN
+	case 2:
+		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOCEN
+	case 3:
+		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIODEN
+	case 4:
+		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOEEN
+	case 5:
+		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOFEN
+	case 6:
+		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOGEN
+	case 7:
+		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOHEN
+	case 8:
+		stm32.RCC.AHB1ENR |= stm32.RCC_AHB1ENR_GPIOIEN
+	default:
+		panic("machine: unknown port")
+	}
+}
+
+// Configure this pin with the given configuration.
+func (p GPIO) Configure(config GPIOConfig) {
+	// Configure the GPIO pin.
+	p.enableClock()
+	port := p.getPort()
+	pin := p.Pin % 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)))
+		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)))
+		p.setAltFunc(0x7)
+	}
+}
+
+func (p GPIO) setAltFunc(af uint32) {
+	port := p.getPort()
+	pin := p.Pin % 16
+	pos := pin * 4
+	if pin >= 8 {
+		port.AFRH = stm32.RegValue(uint32(port.AFRH)&^(0xF<<pos) | ((af & 0xF) << pos))
+	} else {
+		port.AFRL = stm32.RegValue(uint32(port.AFRL)&^(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) {
+	port := p.getPort()
+	pin := p.Pin % 16
+	if high {
+		port.BSRR = 1 << pin
+	} else {
+		port.BSRR = 1 << (pin + 16)
+	}
+}
+
+// UART
+type UART struct {
+	Buffer *RingBuffer
+}
+
+var (
+	// Both UART0 and UART1 refer to USART2.
+	UART0 = UART{Buffer: NewRingBuffer()}
+	UART1 = &UART0
+)
+
+// Configure the UART.
+func (uart UART) Configure(config UARTConfig) {
+	// Default baud rate to 115200.
+	if config.BaudRate == 0 {
+		config.BaudRate = 115200
+	}
+
+	// pins
+	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})
+	}
+
+	// Enable USART2 clock
+	stm32.RCC.APB1ENR |= stm32.RCC_APB1ENR_USART2EN
+
+	/*
+	  Set baud rate(115200)
+	  OVER8 = 0, APB2 = 42mhz
+	  +----------+--------+
+	  | baudrate | BRR    |
+	  +----------+--------+
+	  | 1200     | 0x88B8 |
+	  | 2400     | 0x445C |
+	  | 9600     | 0x1117 |
+	  | 19200    | 0x88C  |
+	  | 38400    | 0x446  |
+	  | 57600    | 0x2D9  |
+	  | 115200   | 0x16D  |
+	  +----------+--------+
+	*/
+	stm32.USART2.BRR = 0x16c
+
+	// Enable USART2 port.
+	stm32.USART2.CR1 = 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)
+	arm.EnableIRQ(stm32.IRQ_USART2)
+}
+
+// WriteByte writes a byte of data to the UART.
+func (uart UART) WriteByte(c byte) error {
+	stm32.USART2.DR = stm32.RegValue(c)
+
+	for (stm32.USART2.SR & stm32.USART_SR_TXE) == 0 {
+	}
+	return nil
+}
+
+//go:export USART2_IRQHandler
+func handleUSART2() {
+	UART1.Receive(byte((stm32.USART2.DR & 0xFF)))
+}

src/machine/spi.go

@@ -1,4 +1,4 @@
-// +build nrf stm32f103xx atsamd21g18a
+// +build js,wasm nrf stm32f103xx atsamd21g18a
 
 package machine
 

src/os/file_other.go

@@ -1,4 +1,4 @@
-// +build wasm
+// +build avr cortexm wasm
 
 package os
 

src/os/file_unix.go

@@ -1,4 +1,4 @@
-// +build darwin linux
+// +build darwin linux,!avr,!cortexm
 
 package os
 

src/reflect/type.go

@@ -134,18 +134,18 @@ func (t Type) String() string {
 }
 
 func (t Type) Kind() Kind {
-	if t % 2 == 0 {
+	if t%2 == 0 {
 		// basic type
 		return Kind((t >> 1) % 32)
 	} else {
-		return Kind(t >> 1) % 8 + 19
+		return Kind(t>>1)%8 + 19
 	}
 }
 
 func (t Type) Elem() Type {
 	switch t.Kind() {
 	case Chan, Ptr, Slice:
-		if (t >> 4) % 2 != 0 {
+		if (t>>4)%2 != 0 {
 			panic("unimplemented: (reflect.Type).Elem() for named types")
 		}
 		return t >> 5

src/reflect/value.go

@@ -335,7 +335,7 @@ func (v Value) Index(i int) Value {
 			typecode: v.Type().Elem(),
 			indirect: true,
 		}
-		addr := uintptr(slice.Data) + elem.Type().Size() * uintptr(i) // pointer to new value
+		addr := uintptr(slice.Data) + elem.Type().Size()*uintptr(i) // pointer to new value
 		elem.value = unsafe.Pointer(addr)
 		return elem
 	case String:
@@ -348,7 +348,7 @@ func (v Value) Index(i int) Value {
 		}
 		return Value{
 			typecode: Uint8.basicType(),
-			value: unsafe.Pointer(uintptr(*(*uint8)(unsafe.Pointer(s.Data + uintptr(i))))),
+			value:    unsafe.Pointer(uintptr(*(*uint8)(unsafe.Pointer(s.Data + uintptr(i))))),
 		}
 	case Array:
 		panic("unimplemented: (reflect.Value).Index()")
@@ -365,6 +365,25 @@ func (v Value) MapIndex(key Value) Value {
 	panic("unimplemented: (reflect.Value).MapIndex()")
 }
 
+func (v Value) MapRange() *MapIter {
+	panic("unimplemented: (reflect.Value).MapRange()")
+}
+
+type MapIter struct {
+}
+
+func (it *MapIter) Key() Value {
+	panic("unimplemented: (*reflect.MapIter).Key()")
+}
+
+func (it *MapIter) Value() Value {
+	panic("unimplemented: (*reflect.MapIter).Value()")
+}
+
+func (it *MapIter) Next() bool {
+	panic("unimplemented: (*reflect.MapIter).Next()")
+}
+
 func (v Value) Set(x Value) {
 	if !v.indirect {
 		panic("reflect: value is not addressable")

src/runtime/arch_arm.go

@@ -1,3 +1,5 @@
+// +build arm,!avr,!cortexm
+
 package runtime
 
 const GOARCH = "arm"

src/runtime/arch_cortexm.go

@@ -1,4 +1,4 @@
-// +build tinygo.arm
+// +build cortexm
 
 package runtime
 

src/runtime/arch_wasm.go

@@ -1,4 +1,4 @@
-// +build wasm,!tinygo.arm,!avr
+// +build wasm
 
 package runtime
 

src/runtime/chan.go

@@ -39,32 +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)
@@ -75,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
 	}
@@ -84,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
@@ -96,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)
@@ -108,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
 	}
@@ -141,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/func.go

@@ -0,0 +1,28 @@
+package runtime
+
+// This file implements some data types that may be useful for some
+// implementations of func values.
+
+import (
+	"unsafe"
+)
+
+// funcValue is the underlying type of func values, depending on which func
+// value representation was used.
+type funcValue struct {
+	context unsafe.Pointer // function context, for closures and bound methods
+	id      uintptr        // ptrtoint of *funcValueWithSignature before lowering, opaque index (non-0) after lowering
+}
+
+// funcValueWithSignature is used before the func lowering pass.
+type funcValueWithSignature struct {
+	funcPtr   uintptr // ptrtoint of the actual function pointer
+	signature *uint8  // pointer to identify this signature (the value is undef)
+}
+
+// getFuncPtr is a dummy function that may be used if the func lowering pass is
+// not used. It is generally too slow but may be a useful fallback to debug the
+// func lowering pass.
+func getFuncPtr(val funcValue, signature *uint8) uintptr {
+	return (*funcValueWithSignature)(unsafe.Pointer(val.id)).funcPtr
+}

src/runtime/interface.go

@@ -43,15 +43,22 @@ type interfaceMethodInfo struct {
 	funcptr   uintptr // bitcast from the actual function pointer
 }
 
-// Pseudo function call used while putting a concrete value in an interface,
-// that must be lowered to a constant uintptr.
-func makeInterface(typecode *uint8, methodSet *interfaceMethodInfo) uintptr
+type typecodeID struct{}
+
+// Pseudo type used before interface lowering. By using a struct instead of a
+// function call, this is simpler to reason about during init interpretation
+// than a function call. Also, by keeping the method set around it is easier to
+// implement interfaceImplements in the interp package.
+type typeInInterface struct {
+	typecode  *typecodeID
+	methodSet *interfaceMethodInfo // nil or a GEP of an array
+}
 
 // Pseudo function call used during a type assert. It is used during interface
 // lowering, to assign the lowest type numbers to the types with the most type
 // asserts. Also, it is replaced with const false if this type assert can never
 // happen.
-func typeAssert(actualType uintptr, assertedType *uint8) bool
+func typeAssert(actualType uintptr, assertedType *typecodeID) bool
 
 // Pseudo function call that returns whether a given type implements all methods
 // of the given interface.

src/runtime/internal/sys/zversion.go

@@ -1 +1,3 @@
-TheVersion = `go0.1.0`
+package sys
+
+const TheVersion = `go0.1.0`

src/runtime/override_js.go

@@ -1,28 +0,0 @@
-// +build js,tinygo.arm avr
-
-package runtime
-
-// This file stubs out some external functions declared by the syscall/js
-// package. They cannot be used on microcontrollers.
-
-type js_ref uint64
-
-//go:linkname js_valueGet syscall/js.valueGet
-func js_valueGet(v js_ref, p string) js_ref {
-	return 0
-}
-
-//go:linkname js_valueNew syscall/js.valueNew
-func js_valueNew(v js_ref, args []js_ref) (js_ref, bool) {
-	return 0, true
-}
-
-//go:linkname js_valueCall syscall/js.valueCall
-func js_valueCall(v js_ref, m string, args []js_ref) (js_ref, bool) {
-	return 0, true
-}
-
-//go:linkname js_stringVal syscall/js.stringVal
-func js_stringVal(x string) js_ref {
-	return 0
-}

src/runtime/panic.go

@@ -27,6 +27,14 @@ func _recover() interface{} {
 	return nil
 }
 
+// See emitNilCheck in compiler/asserts.go.
+// This function is a dummy function that has its first and only parameter
+// marked 'nocapture' to work around a limitation in LLVM: a regular pointer
+// comparison captures the pointer.
+func isnil(ptr *uint8) bool {
+	return ptr == nil
+}
+
 // Panic when trying to dereference a nil pointer.
 func nilpanic() {
 	runtimePanic("nil pointer dereference")
@@ -41,17 +49,3 @@ func lookuppanic() {
 func slicepanic() {
 	runtimePanic("slice out of range")
 }
-
-// Check for bounds in *ssa.MakeSlice.
-func sliceBoundsCheckMake(length, capacity uintptr, max uintptr) {
-	if length > capacity || capacity > max {
-		runtimePanic("slice size out of range")
-	}
-}
-
-// Check for bounds in *ssa.MakeSlice. Supports 64-bit indexes.
-func sliceBoundsCheckMake64(length, capacity uint64, max uintptr) {
-	if length > capacity || capacity > uint64(max) {
-		runtimePanic("slice size out of range")
-	}
-}

src/runtime/print.go

@@ -4,6 +4,10 @@ import (
 	"unsafe"
 )
 
+type stringer interface {
+	String() string
+}
+
 //go:nobounds
 func printstring(s string) {
 	for i := 0; i < len(s); i++ {
@@ -39,7 +43,7 @@ func printuint16(n uint16) {
 	printuint32(uint32(n))
 }
 
-func printint16(n uint16) {
+func printint16(n int16) {
 	printint32(int32(n))
 }
 
@@ -199,8 +203,44 @@ func printnl() {
 
 func printitf(msg interface{}) {
 	switch msg := msg.(type) {
+	case bool:
+		print(msg)
+	case int:
+		print(msg)
+	case int8:
+		print(msg)
+	case int16:
+		print(msg)
+	case int32:
+		print(msg)
+	case int64:
+		print(msg)
+	case uint:
+		print(msg)
+	case uint8:
+		print(msg)
+	case uint16:
+		print(msg)
+	case uint32:
+		print(msg)
+	case uint64:
+		print(msg)
+	case uintptr:
+		print(msg)
+	case float32:
+		print(msg)
+	case float64:
+		print(msg)
+	case complex64:
+		print(msg)
+	case complex128:
+		print(msg)
 	case string:
 		print(msg)
+	case error:
+		print(msg.Error())
+	case stringer:
+		print(msg.String())
 	default:
 		// cast to underlying type
 		itf := *(*_interface)(unsafe.Pointer(&msg))

src/runtime/runtime.go

@@ -84,9 +84,13 @@ func sleep(d int64) {
 	sleepTicks(timeUnit(d / tickMicros))
 }
 
+func nanotime() int64 {
+	return int64(ticks()) * tickMicros
+}
+
 //go:linkname now time.now
 func now() (sec int64, nsec int32, mono int64) {
-	mono = int64(ticks()) * tickMicros
+	mono = nanotime()
 	sec = mono / (1000 * 1000 * 1000)
 	nsec = int32(mono - sec*(1000*1000*1000))
 	return

src/runtime/runtime_cortexm.go

@@ -1,4 +1,4 @@
-// +build tinygo.arm
+// +build cortexm
 
 package runtime
 
@@ -46,10 +46,16 @@ func abort() {
 	}
 }
 
-// Implement memset for compiler-rt.
+// Implement memset for LLVM and compiler-rt.
 //go:export memset
-func memset(ptr unsafe.Pointer, c byte, size uintptr) {
+func libc_memset(ptr unsafe.Pointer, c byte, size uintptr) {
 	for i := uintptr(0); i < size; i++ {
 		*(*byte)(unsafe.Pointer(uintptr(ptr) + i)) = c
 	}
 }
+
+// Implement memmove for LLVM and compiler-rt.
+//go:export memmove
+func libc_memmove(dst, src unsafe.Pointer, size uintptr) {
+	memmove(dst, src, size)
+}

src/runtime/runtime_stm32f407.go

@@ -0,0 +1,208 @@
+// +build stm32,stm32f407
+
+package runtime
+
+import (
+	"device/arm"
+	"device/stm32"
+	"machine"
+)
+
+func init() {
+	initCLK()
+	initTIM3()
+	machine.UART0.Configure(machine.UARTConfig{})
+	initTIM7()
+}
+
+func putchar(c byte) {
+	machine.UART0.WriteByte(c)
+}
+
+const (
+	HSE_STARTUP_TIMEOUT = 0x0500
+	/* PLL Options - See RM0090 Reference Manual pg. 95 */
+	PLL_M = 8 /* PLL_VCO = (HSE_VALUE or HSI_VLAUE / PLL_M) * PLL_N */
+	PLL_N = 336
+	PLL_P = 2 /* SYSCLK = PLL_VCO / PLL_P */
+	PLL_Q = 7 /* USB OTS FS, SDIO and RNG Clock = PLL_VCO / PLL_Q */
+)
+
+/*
+   clock settings
+   +-------------+--------+
+   | HSE         | 8mhz   |
+   | SYSCLK      | 168mhz |
+   | HCLK        | 168mhz |
+   | APB2(PCLK2) | 84mhz  |
+   | APB1(PCLK1) | 42mhz  |
+   +-------------+--------+
+*/
+func initCLK() {
+
+	// Reset clock registers
+	// Set HSION
+	stm32.RCC.CR |= stm32.RCC_CR_HSION
+	for (stm32.RCC.CR & stm32.RCC_CR_HSIRDY) == 0 {
+	}
+
+	// Reset CFGR
+	stm32.RCC.CFGR = 0x00000000
+	// Reset HSEON, CSSON and PLLON
+	stm32.RCC.CR &= 0xFEF6FFFF
+	// Reset PLLCFGR
+	stm32.RCC.PLLCFGR = 0x24003010
+	// Reset HSEBYP
+	stm32.RCC.CR &= 0xFFFBFFFF
+	// Disable all interrupts
+	stm32.RCC.CIR = 0x00000000
+
+	// Set up the clock
+	var startupCounter uint32 = 0
+
+	// Enable HSE
+	stm32.RCC.CR = stm32.RCC_CR_HSEON
+	// Wait till HSE is ready and if timeout is reached exit
+	for {
+		startupCounter++
+		if (stm32.RCC.CR&stm32.RCC_CR_HSERDY != 0) || (startupCounter == HSE_STARTUP_TIMEOUT) {
+			break
+		}
+	}
+	if (stm32.RCC.CR & stm32.RCC_CR_HSERDY) != 0 {
+		// Enable high performance mode, System frequency up to 168MHz
+		stm32.RCC.APB1ENR |= stm32.RCC_APB1ENR_PWREN
+		stm32.PWR.CR |= 0x4000 // PWR_CR_VOS
+		// HCLK = SYSCLK / 1
+		stm32.RCC.CFGR |= (0x0 << stm32.RCC_CFGR_HPRE_Pos)
+		// PCLK2 = HCLK / 2
+		stm32.RCC.CFGR |= (0x4 << stm32.RCC_CFGR_PPRE2_Pos)
+		// PCLK1 = HCLK / 4
+		stm32.RCC.CFGR |= (0x5 << stm32.RCC_CFGR_PPRE1_Pos)
+		// Configure the main PLL
+		// PLL Options - See RM0090 Reference Manual pg. 95
+		stm32.RCC.PLLCFGR = PLL_M | (PLL_N << 6) | (((PLL_P >> 1) - 1) << 16) |
+			(1 << stm32.RCC_PLLCFGR_PLLSRC_Pos) | (PLL_Q << 24)
+		// Enable main PLL
+		stm32.RCC.CR |= stm32.RCC_CR_PLLON
+		// Wait till the main PLL is ready
+		for (stm32.RCC.CR & stm32.RCC_CR_PLLRDY) == 0 {
+		}
+		// Configure Flash prefetch, Instruction cache, Data cache and wait state
+		stm32.FLASH.ACR = stm32.FLASH_ACR_ICEN | stm32.FLASH_ACR_DCEN | (5 << stm32.FLASH_ACR_LATENCY_Pos)
+		// Select the main PLL as system clock source
+		stm32.RCC.CFGR &^= stm32.RCC_CFGR_SW0 | stm32.RCC_CFGR_SW1
+		stm32.RCC.CFGR |= (0x2 << stm32.RCC_CFGR_SW0_Pos)
+		for (stm32.RCC.CFGR & (0x3 << stm32.RCC_CFGR_SWS0_Pos)) != (0x2 << stm32.RCC_CFGR_SWS0_Pos) {
+		}
+
+	} else {
+		// If HSE failed to start up, the application will have wrong clock configuration
+		for {
+		}
+	}
+	// Enable the CCM RAM clock
+	stm32.RCC.AHB1ENR |= (1 << 20)
+
+}
+
+const tickMicros = 1000
+
+var (
+	// tick in milliseconds
+	tickCount timeUnit
+)
+
+//go:volatile
+type isrFlag bool
+
+var timerWakeup isrFlag
+
+// Enable the TIM3 clock.(sleep count)
+func initTIM3() {
+	stm32.RCC.APB1ENR |= stm32.RCC_APB1ENR_TIM3EN
+
+	arm.SetPriority(stm32.IRQ_TIM3, 0xc3)
+	arm.EnableIRQ(stm32.IRQ_TIM3)
+}
+
+// Enable the TIM7 clock.(tick count)
+func initTIM7() {
+	stm32.RCC.APB1ENR |= stm32.RCC_APB1ENR_TIM7EN
+
+	// CK_INT = APB1 x2 = 84mhz
+	stm32.TIM7.PSC = 84000000/10000 - 1     // 84mhz to 10khz(0.1ms)
+	stm32.TIM7.ARR = stm32.RegValue(10) - 1 // interrupt per 1ms
+
+	// Enable the hardware interrupt.
+	stm32.TIM7.DIER |= stm32.TIM_DIER_UIE
+
+	// Enable the timer.
+	stm32.TIM7.CR1 |= stm32.TIM_CR1_CEN
+
+	arm.SetPriority(stm32.IRQ_TIM7, 0xc1)
+	arm.EnableIRQ(stm32.IRQ_TIM7)
+}
+
+const asyncScheduler = false
+
+// sleepTicks should sleep for specific number of microseconds.
+func sleepTicks(d timeUnit) {
+	timerSleep(uint32(d))
+}
+
+// number of ticks (microseconds) since start.
+func ticks() timeUnit {
+	// milliseconds to microseconds
+	return tickCount * 1000
+}
+
+// ticks are in microseconds
+func timerSleep(ticks uint32) {
+	timerWakeup = false
+
+	// CK_INT = APB1 x2 = 84mhz
+	// prescale counter down from 84mhz to 10khz aka 0.1 ms frequency.
+	stm32.TIM3.PSC = 84000000/10000 - 1 // 8399
+
+	// set duty aka duration
+	arr := (ticks / 100) - 1 // convert from microseconds to 0.1 ms
+	if arr == 0 {
+		arr = 1 // avoid blocking
+	}
+	stm32.TIM3.ARR = stm32.RegValue(arr)
+
+	// Enable the hardware interrupt.
+	stm32.TIM3.DIER |= stm32.TIM_DIER_UIE
+
+	// Enable the timer.
+	stm32.TIM3.CR1 |= stm32.TIM_CR1_CEN
+
+	// wait till timer wakes up
+	for !timerWakeup {
+		arm.Asm("wfi")
+	}
+}
+
+//go:export TIM3_IRQHandler
+func handleTIM3() {
+	if (stm32.TIM3.SR & stm32.TIM_SR_UIF) > 0 {
+		// Disable the timer.
+		stm32.TIM3.CR1 &^= stm32.TIM_CR1_CEN
+
+		// clear the update flag
+		stm32.TIM3.SR &^= stm32.TIM_SR_UIF
+
+		// timer was triggered
+		timerWakeup = true
+	}
+}
+
+//go:export TIM7_IRQHandler
+func handleTIM7() {
+	if (stm32.TIM7.SR & stm32.TIM_SR_UIF) > 0 {
+		// clear the update flag
+		stm32.TIM7.SR &^= stm32.TIM_SR_UIF
+		tickCount++
+	}
+}

src/runtime/runtime_unix.go

@@ -1,4 +1,4 @@
-// +build darwin linux
+// +build darwin linux,!avr,!cortexm
 
 package runtime
 

src/runtime/runtime_wasm.go

@@ -1,4 +1,4 @@
-// +build wasm,!tinygo.arm,!avr
+// +build wasm
 
 package runtime
 
@@ -37,6 +37,11 @@ func putchar(c byte) {
 	resource_write(stdout, &c, 1)
 }
 
+//go:linkname setEventHandler syscall/js.setEventHandler
+func setEventHandler(fn func()) {
+	// TODO
+}
+
 //go:export go_scheduler
 func go_scheduler() {
 	scheduler()

src/runtime/scheduler.go

@@ -49,13 +49,17 @@ func (t *coroutine) promise() *taskState {
 
 func makeGoroutine(*uint8) *uint8
 
+// Compiler stub to get the current goroutine. Calls to this function are
+// removed in the goroutine lowering pass.
+func getCoroutine() *coroutine
+
 // State/promise of a task. Internally represented as:
 //
 //     {i8* next, i1 commaOk, i32/i64 data}
 type taskState struct {
-	next    *coroutine
-	commaOk bool // 'comma-ok' flag for channel receive operation
-	data    uint
+	next *coroutine
+	ptr  unsafe.Pointer
+	data uint
 }
 
 // Queues used by the scheduler.
@@ -107,6 +111,24 @@ func activateTask(task *coroutine) {
 	runqueuePushBack(task)
 }
 
+// getTaskPromisePtr is a helper function to set the current .ptr field of a
+// coroutine promise.
+func setTaskPromisePtr(task *coroutine, value unsafe.Pointer) {
+	task.promise().ptr = value
+}
+
+// getTaskPromisePtr is a helper function to get the current .ptr field from a
+// coroutine promise.
+func getTaskPromisePtr(task *coroutine) unsafe.Pointer {
+	return task.promise().ptr
+}
+
+// getTaskPromiseData is a helper function to get the current .data field of a
+// coroutine promise.
+func getTaskPromiseData(task *coroutine) uint {
+	return task.promise().data
+}
+
 // Add this task to the end of the run queue. May also destroy the task if it's
 // done.
 func runqueuePushBack(t *coroutine) {

src/syscall/errno.go

@@ -0,0 +1,30 @@
+package syscall
+
+// Most code here has been copied from the Go sources:
+//   https://github.com/golang/go/blob/go1.12/src/syscall/syscall_js.go
+// It has the following copyright note:
+//
+//     Copyright 2018 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.
+
+// An Errno is an unsigned number describing an error condition.
+// It implements the error interface. The zero Errno is by convention
+// a non-error, so code to convert from Errno to error should use:
+//      err = nil
+//      if errno != 0 {
+//              err = errno
+//      }
+type Errno uintptr
+
+func (e Errno) Error() string {
+	return "errno " + itoa(int(e))
+}
+
+func (e Errno) Temporary() bool {
+	return e == EINTR || e == EMFILE || e.Timeout()
+}
+
+func (e Errno) Timeout() bool {
+	return e == EAGAIN || e == EWOULDBLOCK || e == ETIMEDOUT
+}

src/syscall/str.go

@@ -0,0 +1,24 @@
+// Copyright 2009 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 syscall
+
+func itoa(val int) string { // do it here rather than with fmt to avoid dependency
+	if val < 0 {
+		return "-" + uitoa(uint(-val))
+	}
+	return uitoa(uint(val))
+}
+
+func uitoa(val uint) string {
+	var buf [32]byte // big enough for int64
+	i := len(buf) - 1
+	for val >= 10 {
+		buf[i] = byte(val%10 + '0')
+		i--
+		val /= 10
+	}
+	buf[i] = byte(val + '0')
+	return string(buf[i:])
+}

src/syscall/syscall_baremetal.go

@@ -0,0 +1,123 @@
+// +build avr cortexm
+
+package syscall
+
+// Most code here has been copied from the Go sources:
+//   https://github.com/golang/go/blob/go1.12/src/syscall/syscall_js.go
+// It has the following copyright note:
+//
+//     Copyright 2018 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.
+
+// A Signal is a number describing a process signal.
+// It implements the os.Signal interface.
+type Signal int
+
+const (
+	_ Signal = iota
+	SIGCHLD
+	SIGINT
+	SIGKILL
+	SIGTRAP
+	SIGQUIT
+	SIGTERM
+)
+
+// File system
+
+const (
+	Stdin  = 0
+	Stdout = 1
+	Stderr = 2
+)
+
+const (
+	O_RDONLY = 0
+	O_WRONLY = 1
+	O_RDWR   = 2
+
+	O_CREAT  = 0100
+	O_CREATE = O_CREAT
+	O_TRUNC  = 01000
+	O_APPEND = 02000
+	O_EXCL   = 0200
+	O_SYNC   = 010000
+
+	O_CLOEXEC = 0
+)
+
+func Getenv(key string) (value string, found bool) {
+	return "", false // stub
+}
+
+func Open(path string, mode int, perm uint32) (fd int, err error) {
+	return 0, ENOSYS
+}
+
+func Read(fd int, p []byte) (n int, err error) {
+	return 0, ENOSYS
+}
+
+func Seek(fd int, offset int64, whence int) (off int64, err error) {
+	return 0, ENOSYS
+}
+
+func Close(fd int) (err error) {
+	return ENOSYS
+}
+
+// Processes
+
+type WaitStatus uint32
+
+func (w WaitStatus) Exited() bool       { return false }
+func (w WaitStatus) ExitStatus() int    { return 0 }
+func (w WaitStatus) Signaled() bool     { return false }
+func (w WaitStatus) Signal() Signal     { return 0 }
+func (w WaitStatus) CoreDump() bool     { return false }
+func (w WaitStatus) Stopped() bool      { return false }
+func (w WaitStatus) Continued() bool    { return false }
+func (w WaitStatus) StopSignal() Signal { return 0 }
+func (w WaitStatus) TrapCause() int     { return 0 }
+
+// XXX made up
+type Rusage struct {
+	Utime Timeval
+	Stime Timeval
+}
+
+// XXX made up
+type ProcAttr struct {
+	Dir   string
+	Env   []string
+	Files []uintptr
+	Sys   *SysProcAttr
+}
+
+type SysProcAttr struct {
+}
+
+func Getegid() int                      { return 1 }
+func Geteuid() int                      { return 1 }
+func Getgid() int                       { return 1 }
+func Getgroups() ([]int, error)         { return []int{1}, nil }
+func Getppid() int                      { return 2 }
+func Getpid() int                       { return 3 }
+func Gettimeofday(tv *Timeval) error    { return ENOSYS }
+func Getuid() int                       { return 1 }
+func Kill(pid int, signum Signal) error { return ENOSYS }
+func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
+	return 0, ENOSYS
+}
+func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error) {
+	return 0, 0, ENOSYS
+}
+func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
+	return 0, ENOSYS
+}
+
+type Timeval struct {
+	Sec  int64
+	Usec int64
+}

src/syscall/syscall_darwin.go

@@ -0,0 +1,51 @@
+package syscall
+
+// This file defines errno and constants to match the darwin libsystem ABI.
+// Values have been determined experimentally by compiling some C code on macOS
+// with Clang and looking at the resulting LLVM IR.
+
+// This function returns the error location in the darwin ABI.
+// Discovered by compiling the following code using Clang:
+//
+//     #include <errno.h>
+//     int getErrno() {
+//         return errno;
+//     }
+//
+//go:export __error
+func libc___error() *int32
+
+// getErrno returns the current C errno. It may not have been caused by the last
+// call, so it should only be relied upon when the last call indicates an error
+// (for example, by returning -1).
+func getErrno() Errno {
+	errptr := libc___error()
+	return Errno(uintptr(*errptr))
+}
+
+const (
+	ENOENT      Errno = 2
+	EINTR       Errno = 4
+	EMFILE      Errno = 24
+	EAGAIN      Errno = 35
+	ETIMEDOUT   Errno = 60
+	ENOSYS      Errno = 78
+	EWOULDBLOCK Errno = EAGAIN
+)
+
+type Signal int
+
+const (
+	SIGCHLD Signal = 20
+	SIGINT  Signal = 2
+	SIGKILL Signal = 9
+	SIGTRAP Signal = 5
+	SIGQUIT Signal = 3
+	SIGTERM Signal = 15
+)
+
+const (
+	O_RDONLY = 0
+	O_WRONLY = 1
+	O_RDWR   = 2
+)

src/syscall/syscall_libc.go

@@ -0,0 +1,57 @@
+// +build darwin
+
+package syscall
+
+import (
+	"unsafe"
+)
+
+func Close(fd int) (err error) {
+	return ENOSYS // TODO
+}
+
+func Write(fd int, p []byte) (n int, err error) {
+	buf, count := splitSlice(p)
+	n = libc_write(int32(fd), buf, uint(count))
+	if n < 0 {
+		err = getErrno()
+	}
+	return
+}
+
+func Read(fd int, p []byte) (n int, err error) {
+	return 0, ENOSYS // TODO
+}
+
+func Seek(fd int, offset int64, whence int) (off int64, err error) {
+	return 0, ENOSYS // TODO
+}
+
+func Open(path string, mode int, perm uint32) (fd int, err error) {
+	return 0, ENOSYS // TODO
+}
+
+func Kill(pid int, sig Signal) (err error) {
+	return ENOSYS // TODO
+}
+
+func Getpid() (pid int) {
+	panic("unimplemented: getpid") // TODO
+}
+
+func Getenv(key string) (value string, found bool) {
+	return "", false // TODO
+}
+
+func splitSlice(p []byte) (buf *byte, len uintptr) {
+	slice := (*struct {
+		buf *byte
+		len uintptr
+		cap uintptr
+	})(unsafe.Pointer(&p))
+	return slice.buf, slice.len
+}
+
+// ssize_t write(int fd, const void *buf, size_t count)
+//go:export write
+func libc_write(fd int32, buf *byte, count uint) int

src/syscall/tables_baremetal.go

@@ -0,0 +1,371 @@
+// Copyright 2013 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.
+
+// +build avr cortexm
+
+package syscall
+
+// TODO: generate with runtime/mknacl.sh, allow override with IRT.
+const (
+	sys_null                 = 1
+	sys_nameservice          = 2
+	sys_dup                  = 8
+	sys_dup2                 = 9
+	sys_open                 = 10
+	sys_close                = 11
+	sys_read                 = 12
+	sys_write                = 13
+	sys_lseek                = 14
+	sys_stat                 = 16
+	sys_fstat                = 17
+	sys_chmod                = 18
+	sys_isatty               = 19
+	sys_brk                  = 20
+	sys_mmap                 = 21
+	sys_munmap               = 22
+	sys_getdents             = 23
+	sys_mprotect             = 24
+	sys_list_mappings        = 25
+	sys_exit                 = 30
+	sys_getpid               = 31
+	sys_sched_yield          = 32
+	sys_sysconf              = 33
+	sys_gettimeofday         = 40
+	sys_clock                = 41
+	sys_nanosleep            = 42
+	sys_clock_getres         = 43
+	sys_clock_gettime        = 44
+	sys_mkdir                = 45
+	sys_rmdir                = 46
+	sys_chdir                = 47
+	sys_getcwd               = 48
+	sys_unlink               = 49
+	sys_imc_makeboundsock    = 60
+	sys_imc_accept           = 61
+	sys_imc_connect          = 62
+	sys_imc_sendmsg          = 63
+	sys_imc_recvmsg          = 64
+	sys_imc_mem_obj_create   = 65
+	sys_imc_socketpair       = 66
+	sys_mutex_create         = 70
+	sys_mutex_lock           = 71
+	sys_mutex_trylock        = 72
+	sys_mutex_unlock         = 73
+	sys_cond_create          = 74
+	sys_cond_wait            = 75
+	sys_cond_signal          = 76
+	sys_cond_broadcast       = 77
+	sys_cond_timed_wait_abs  = 79
+	sys_thread_create        = 80
+	sys_thread_exit          = 81
+	sys_tls_init             = 82
+	sys_thread_nice          = 83
+	sys_tls_get              = 84
+	sys_second_tls_set       = 85
+	sys_second_tls_get       = 86
+	sys_exception_handler    = 87
+	sys_exception_stack      = 88
+	sys_exception_clear_flag = 89
+	sys_sem_create           = 100
+	sys_sem_wait             = 101
+	sys_sem_post             = 102
+	sys_sem_get_value        = 103
+	sys_dyncode_create       = 104
+	sys_dyncode_modify       = 105
+	sys_dyncode_delete       = 106
+	sys_test_infoleak        = 109
+	sys_test_crash           = 110
+	sys_test_syscall_1       = 111
+	sys_test_syscall_2       = 112
+	sys_futex_wait_abs       = 120
+	sys_futex_wake           = 121
+	sys_pread                = 130
+	sys_pwrite               = 131
+	sys_truncate             = 140
+	sys_lstat                = 141
+	sys_link                 = 142
+	sys_rename               = 143
+	sys_symlink              = 144
+	sys_access               = 145
+	sys_readlink             = 146
+	sys_utimes               = 147
+	sys_get_random_bytes     = 150
+)
+
+// TODO: Auto-generate some day. (Hard-coded in binaries so not likely to change.)
+const (
+	// native_client/src/trusted/service_runtime/include/sys/errno.h
+	// The errors are mainly copied from Linux.
+	EPERM           Errno = 1       /* Operation not permitted */
+	ENOENT          Errno = 2       /* No such file or directory */
+	ESRCH           Errno = 3       /* No such process */
+	EINTR           Errno = 4       /* Interrupted system call */
+	EIO             Errno = 5       /* I/O error */
+	ENXIO           Errno = 6       /* No such device or address */
+	E2BIG           Errno = 7       /* Argument list too long */
+	ENOEXEC         Errno = 8       /* Exec format error */
+	EBADF           Errno = 9       /* Bad file number */
+	ECHILD          Errno = 10      /* No child processes */
+	EAGAIN          Errno = 11      /* Try again */
+	ENOMEM          Errno = 12      /* Out of memory */
+	EACCES          Errno = 13      /* Permission denied */
+	EFAULT          Errno = 14      /* Bad address */
+	EBUSY           Errno = 16      /* Device or resource busy */
+	EEXIST          Errno = 17      /* File exists */
+	EXDEV           Errno = 18      /* Cross-device link */
+	ENODEV          Errno = 19      /* No such device */
+	ENOTDIR         Errno = 20      /* Not a directory */
+	EISDIR          Errno = 21      /* Is a directory */
+	EINVAL          Errno = 22      /* Invalid argument */
+	ENFILE          Errno = 23      /* File table overflow */
+	EMFILE          Errno = 24      /* Too many open files */
+	ENOTTY          Errno = 25      /* Not a typewriter */
+	EFBIG           Errno = 27      /* File too large */
+	ENOSPC          Errno = 28      /* No space left on device */
+	ESPIPE          Errno = 29      /* Illegal seek */
+	EROFS           Errno = 30      /* Read-only file system */
+	EMLINK          Errno = 31      /* Too many links */
+	EPIPE           Errno = 32      /* Broken pipe */
+	ENAMETOOLONG    Errno = 36      /* File name too long */
+	ENOSYS          Errno = 38      /* Function not implemented */
+	EDQUOT          Errno = 122     /* Quota exceeded */
+	EDOM            Errno = 33      /* Math arg out of domain of func */
+	ERANGE          Errno = 34      /* Math result not representable */
+	EDEADLK         Errno = 35      /* Deadlock condition */
+	ENOLCK          Errno = 37      /* No record locks available */
+	ENOTEMPTY       Errno = 39      /* Directory not empty */
+	ELOOP           Errno = 40      /* Too many symbolic links */
+	ENOMSG          Errno = 42      /* No message of desired type */
+	EIDRM           Errno = 43      /* Identifier removed */
+	ECHRNG          Errno = 44      /* Channel number out of range */
+	EL2NSYNC        Errno = 45      /* Level 2 not synchronized */
+	EL3HLT          Errno = 46      /* Level 3 halted */
+	EL3RST          Errno = 47      /* Level 3 reset */
+	ELNRNG          Errno = 48      /* Link number out of range */
+	EUNATCH         Errno = 49      /* Protocol driver not attached */
+	ENOCSI          Errno = 50      /* No CSI structure available */
+	EL2HLT          Errno = 51      /* Level 2 halted */
+	EBADE           Errno = 52      /* Invalid exchange */
+	EBADR           Errno = 53      /* Invalid request descriptor */
+	EXFULL          Errno = 54      /* Exchange full */
+	ENOANO          Errno = 55      /* No anode */
+	EBADRQC         Errno = 56      /* Invalid request code */
+	EBADSLT         Errno = 57      /* Invalid slot */
+	EDEADLOCK       Errno = EDEADLK /* File locking deadlock error */
+	EBFONT          Errno = 59      /* Bad font file fmt */
+	ENOSTR          Errno = 60      /* Device not a stream */
+	ENODATA         Errno = 61      /* No data (for no delay io) */
+	ETIME           Errno = 62      /* Timer expired */
+	ENOSR           Errno = 63      /* Out of streams resources */
+	ENONET          Errno = 64      /* Machine is not on the network */
+	ENOPKG          Errno = 65      /* Package not installed */
+	EREMOTE         Errno = 66      /* The object is remote */
+	ENOLINK         Errno = 67      /* The link has been severed */
+	EADV            Errno = 68      /* Advertise error */
+	ESRMNT          Errno = 69      /* Srmount error */
+	ECOMM           Errno = 70      /* Communication error on send */
+	EPROTO          Errno = 71      /* Protocol error */
+	EMULTIHOP       Errno = 72      /* Multihop attempted */
+	EDOTDOT         Errno = 73      /* Cross mount point (not really error) */
+	EBADMSG         Errno = 74      /* Trying to read unreadable message */
+	EOVERFLOW       Errno = 75      /* Value too large for defined data type */
+	ENOTUNIQ        Errno = 76      /* Given log. name not unique */
+	EBADFD          Errno = 77      /* f.d. invalid for this operation */
+	EREMCHG         Errno = 78      /* Remote address changed */
+	ELIBACC         Errno = 79      /* Can't access a needed shared lib */
+	ELIBBAD         Errno = 80      /* Accessing a corrupted shared lib */
+	ELIBSCN         Errno = 81      /* .lib section in a.out corrupted */
+	ELIBMAX         Errno = 82      /* Attempting to link in too many libs */
+	ELIBEXEC        Errno = 83      /* Attempting to exec a shared library */
+	EILSEQ          Errno = 84
+	EUSERS          Errno = 87
+	ENOTSOCK        Errno = 88  /* Socket operation on non-socket */
+	EDESTADDRREQ    Errno = 89  /* Destination address required */
+	EMSGSIZE        Errno = 90  /* Message too long */
+	EPROTOTYPE      Errno = 91  /* Protocol wrong type for socket */
+	ENOPROTOOPT     Errno = 92  /* Protocol not available */
+	EPROTONOSUPPORT Errno = 93  /* Unknown protocol */
+	ESOCKTNOSUPPORT Errno = 94  /* Socket type not supported */
+	EOPNOTSUPP      Errno = 95  /* Operation not supported on transport endpoint */
+	EPFNOSUPPORT    Errno = 96  /* Protocol family not supported */
+	EAFNOSUPPORT    Errno = 97  /* Address family not supported by protocol family */
+	EADDRINUSE      Errno = 98  /* Address already in use */
+	EADDRNOTAVAIL   Errno = 99  /* Address not available */
+	ENETDOWN        Errno = 100 /* Network interface is not configured */
+	ENETUNREACH     Errno = 101 /* Network is unreachable */
+	ENETRESET       Errno = 102
+	ECONNABORTED    Errno = 103 /* Connection aborted */
+	ECONNRESET      Errno = 104 /* Connection reset by peer */
+	ENOBUFS         Errno = 105 /* No buffer space available */
+	EISCONN         Errno = 106 /* Socket is already connected */
+	ENOTCONN        Errno = 107 /* Socket is not connected */
+	ESHUTDOWN       Errno = 108 /* Can't send after socket shutdown */
+	ETOOMANYREFS    Errno = 109
+	ETIMEDOUT       Errno = 110 /* Connection timed out */
+	ECONNREFUSED    Errno = 111 /* Connection refused */
+	EHOSTDOWN       Errno = 112 /* Host is down */
+	EHOSTUNREACH    Errno = 113 /* Host is unreachable */
+	EALREADY        Errno = 114 /* Socket already connected */
+	EINPROGRESS     Errno = 115 /* Connection already in progress */
+	ESTALE          Errno = 116
+	ENOTSUP         Errno = EOPNOTSUPP /* Not supported */
+	ENOMEDIUM       Errno = 123        /* No medium (in tape drive) */
+	ECANCELED       Errno = 125        /* Operation canceled. */
+	ELBIN           Errno = 2048       /* Inode is remote (not really error) */
+	EFTYPE          Errno = 2049       /* Inappropriate file type or format */
+	ENMFILE         Errno = 2050       /* No more files */
+	EPROCLIM        Errno = 2051
+	ENOSHARE        Errno = 2052   /* No such host or network path */
+	ECASECLASH      Errno = 2053   /* Filename exists with different case */
+	EWOULDBLOCK     Errno = EAGAIN /* Operation would block */
+)
+
+// Do the interface allocations only once for common
+// Errno values.
+var (
+	errEAGAIN error = EAGAIN
+	errEINVAL error = EINVAL
+	errENOENT error = ENOENT
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e Errno) error {
+	switch e {
+	case 0:
+		return nil
+	case EAGAIN:
+		return errEAGAIN
+	case EINVAL:
+		return errEINVAL
+	case ENOENT:
+		return errENOENT
+	}
+	return e
+}
+
+var errnoByCode = map[string]Errno{
+	"EPERM":           EPERM,
+	"ENOENT":          ENOENT,
+	"ESRCH":           ESRCH,
+	"EINTR":           EINTR,
+	"EIO":             EIO,
+	"ENXIO":           ENXIO,
+	"E2BIG":           E2BIG,
+	"ENOEXEC":         ENOEXEC,
+	"EBADF":           EBADF,
+	"ECHILD":          ECHILD,
+	"EAGAIN":          EAGAIN,
+	"ENOMEM":          ENOMEM,
+	"EACCES":          EACCES,
+	"EFAULT":          EFAULT,
+	"EBUSY":           EBUSY,
+	"EEXIST":          EEXIST,
+	"EXDEV":           EXDEV,
+	"ENODEV":          ENODEV,
+	"ENOTDIR":         ENOTDIR,
+	"EISDIR":          EISDIR,
+	"EINVAL":          EINVAL,
+	"ENFILE":          ENFILE,
+	"EMFILE":          EMFILE,
+	"ENOTTY":          ENOTTY,
+	"EFBIG":           EFBIG,
+	"ENOSPC":          ENOSPC,
+	"ESPIPE":          ESPIPE,
+	"EROFS":           EROFS,
+	"EMLINK":          EMLINK,
+	"EPIPE":           EPIPE,
+	"ENAMETOOLONG":    ENAMETOOLONG,
+	"ENOSYS":          ENOSYS,
+	"EDQUOT":          EDQUOT,
+	"EDOM":            EDOM,
+	"ERANGE":          ERANGE,
+	"EDEADLK":         EDEADLK,
+	"ENOLCK":          ENOLCK,
+	"ENOTEMPTY":       ENOTEMPTY,
+	"ELOOP":           ELOOP,
+	"ENOMSG":          ENOMSG,
+	"EIDRM":           EIDRM,
+	"ECHRNG":          ECHRNG,
+	"EL2NSYNC":        EL2NSYNC,
+	"EL3HLT":          EL3HLT,
+	"EL3RST":          EL3RST,
+	"ELNRNG":          ELNRNG,
+	"EUNATCH":         EUNATCH,
+	"ENOCSI":          ENOCSI,
+	"EL2HLT":          EL2HLT,
+	"EBADE":           EBADE,
+	"EBADR":           EBADR,
+	"EXFULL":          EXFULL,
+	"ENOANO":          ENOANO,
+	"EBADRQC":         EBADRQC,
+	"EBADSLT":         EBADSLT,
+	"EDEADLOCK":       EDEADLOCK,
+	"EBFONT":          EBFONT,
+	"ENOSTR":          ENOSTR,
+	"ENODATA":         ENODATA,
+	"ETIME":           ETIME,
+	"ENOSR":           ENOSR,
+	"ENONET":          ENONET,
+	"ENOPKG":          ENOPKG,
+	"EREMOTE":         EREMOTE,
+	"ENOLINK":         ENOLINK,
+	"EADV":            EADV,
+	"ESRMNT":          ESRMNT,
+	"ECOMM":           ECOMM,
+	"EPROTO":          EPROTO,
+	"EMULTIHOP":       EMULTIHOP,
+	"EDOTDOT":         EDOTDOT,
+	"EBADMSG":         EBADMSG,
+	"EOVERFLOW":       EOVERFLOW,
+	"ENOTUNIQ":        ENOTUNIQ,
+	"EBADFD":          EBADFD,
+	"EREMCHG":         EREMCHG,
+	"ELIBACC":         ELIBACC,
+	"ELIBBAD":         ELIBBAD,
+	"ELIBSCN":         ELIBSCN,
+	"ELIBMAX":         ELIBMAX,
+	"ELIBEXEC":        ELIBEXEC,
+	"EILSEQ":          EILSEQ,
+	"EUSERS":          EUSERS,
+	"ENOTSOCK":        ENOTSOCK,
+	"EDESTADDRREQ":    EDESTADDRREQ,
+	"EMSGSIZE":        EMSGSIZE,
+	"EPROTOTYPE":      EPROTOTYPE,
+	"ENOPROTOOPT":     ENOPROTOOPT,
+	"EPROTONOSUPPORT": EPROTONOSUPPORT,
+	"ESOCKTNOSUPPORT": ESOCKTNOSUPPORT,
+	"EOPNOTSUPP":      EOPNOTSUPP,
+	"EPFNOSUPPORT":    EPFNOSUPPORT,
+	"EAFNOSUPPORT":    EAFNOSUPPORT,
+	"EADDRINUSE":      EADDRINUSE,
+	"EADDRNOTAVAIL":   EADDRNOTAVAIL,
+	"ENETDOWN":        ENETDOWN,
+	"ENETUNREACH":     ENETUNREACH,
+	"ENETRESET":       ENETRESET,
+	"ECONNABORTED":    ECONNABORTED,
+	"ECONNRESET":      ECONNRESET,
+	"ENOBUFS":         ENOBUFS,
+	"EISCONN":         EISCONN,
+	"ENOTCONN":        ENOTCONN,
+	"ESHUTDOWN":       ESHUTDOWN,
+	"ETOOMANYREFS":    ETOOMANYREFS,
+	"ETIMEDOUT":       ETIMEDOUT,
+	"ECONNREFUSED":    ECONNREFUSED,
+	"EHOSTDOWN":       EHOSTDOWN,
+	"EHOSTUNREACH":    EHOSTUNREACH,
+	"EALREADY":        EALREADY,
+	"EINPROGRESS":     EINPROGRESS,
+	"ESTALE":          ESTALE,
+	"ENOTSUP":         ENOTSUP,
+	"ENOMEDIUM":       ENOMEDIUM,
+	"ECANCELED":       ECANCELED,
+	"ELBIN":           ELBIN,
+	"EFTYPE":          EFTYPE,
+	"ENMFILE":         ENMFILE,
+	"EPROCLIM":        EPROCLIM,
+	"ENOSHARE":        ENOSHARE,
+	"ECASECLASH":      ECASECLASH,
+	"EWOULDBLOCK":     EWOULDBLOCK,
+}

src/unsafe/unsafe.go

@@ -1,3 +0,0 @@
-package unsafe
-
-// dummy

target.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"os/exec"
 	"os/user"
 	"path/filepath"
 	"runtime"
@@ -211,7 +212,7 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		GOOS:      goos,
 		GOARCH:    goarch,
 		BuildTags: []string{goos, goarch},
-		Compiler:  commands["clang"],
+		Compiler:  "clang",
 		Linker:    "cc",
 		GDB:       "gdb",
 		GDBCmds:   []string{"run"},
@@ -310,3 +311,60 @@ func getHomeDir() string {
 	}
 	return u.HomeDir
 }
+
+// getGoroot returns an appropriate GOROOT from various sources. If it can't be
+// found, it returns an empty string.
+func getGoroot() string {
+	goroot := os.Getenv("GOROOT")
+	if goroot != "" {
+		// An explicitly set GOROOT always has preference.
+		return goroot
+	}
+
+	// Check for the location of the 'go' binary and base GOROOT on that.
+	binpath, err := exec.LookPath("go")
+	if err == nil {
+		binpath, err = filepath.EvalSymlinks(binpath)
+		if err == nil {
+			goroot := filepath.Dir(filepath.Dir(binpath))
+			if isGoroot(goroot) {
+				return goroot
+			}
+		}
+	}
+
+	// Check what GOROOT was at compile time.
+	if isGoroot(runtime.GOROOT()) {
+		return runtime.GOROOT()
+	}
+
+	// Check for some standard locations, as a last resort.
+	var candidates []string
+	switch runtime.GOOS {
+	case "linux":
+		candidates = []string{
+			"/usr/local/go", // manually installed
+			"/usr/lib/go",   // from the distribution
+		}
+	case "darwin":
+		candidates = []string{
+			"/usr/local/go",             // manually installed
+			"/usr/local/opt/go/libexec", // from Homebrew
+		}
+	}
+
+	for _, candidate := range candidates {
+		if isGoroot(candidate) {
+			return candidate
+		}
+	}
+
+	// Can't find GOROOT...
+	return ""
+}
+
+// isGoroot checks whether the given path looks like a GOROOT.
+func isGoroot(goroot string) bool {
+	_, err := os.Stat(filepath.Join(goroot, "src", "runtime", "internal", "sys", "zversion.go"))
+	return err == nil
+}

targets/arm.ld

@@ -54,6 +54,7 @@ SECTIONS
 
     /DISCARD/ :
     {
+        *(.ARM.exidx)      /* causes 'no memory region specified' error in lld */
         *(.ARM.exidx.*)    /* causes spurious 'undefined reference' errors */
     }
 }