Merge remote-tracking branch 'ardnew/feature/usb-common' into feature/usb-common

This is fake debug info. It doesn't point to a source location because
there is no source location. However, it helps to correctly attribute
code size usage to particular packages.

I've also updated builder/sizes.go with some debugging helpers.

.circleci/config.yml

@@ -17,18 +17,15 @@ commands:
             echo 'deb https://apt.llvm.org/buster/ llvm-toolchain-buster-<<parameters.llvm>> main' | sudo tee /etc/apt/sources.list.d/llvm.list
             wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
             sudo apt-get update
-            sudo apt-get install \
+            sudo apt-get install --no-install-recommends \
                 llvm-<<parameters.llvm>>-dev \
                 clang-<<parameters.llvm>> \
                 libclang-<<parameters.llvm>>-dev \
                 lld-<<parameters.llvm>> \
-                gcc-arm-linux-gnueabihf \
-                gcc-aarch64-linux-gnu \
                 qemu-system-arm \
                 qemu-user \
                 gcc-avr \
                 avr-libc
-            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-8-dev
   install-node:
     steps:
       - run:
@@ -68,24 +65,27 @@ commands:
     steps:
       - restore_cache:
           keys:
-            - llvm-source-11-v1
+            - llvm-source-11-v2
       - run:
           name: "Fetch LLVM source"
           command: make llvm-source
       - save_cache:
-          key: llvm-source-11-v1
+          key: llvm-source-11-v2
           paths:
-            - llvm-project
+            - llvm-project/clang/lib/Headers
+            - llvm-project/clang/include
+            - llvm-project/lld/include
+            - llvm-project/llvm/include
   build-wasi-libc:
     steps:
       - restore_cache:
           keys:
-            - wasi-libc-sysroot-v3
+            - wasi-libc-sysroot-v4
       - run:
           name: "Build wasi-libc"
           command: make wasi-libc
       - save_cache:
-          key: wasi-libc-sysroot-v3
+          key: wasi-libc-sysroot-v4
           paths:
             - lib/wasi-libc/sysroot
   test-linux:
@@ -108,13 +108,16 @@ commands:
       - run: go install -tags=llvm<<parameters.llvm>> .
       - restore_cache:
           keys:
-            - wasi-libc-sysroot-systemclang-v2
+            - wasi-libc-sysroot-systemclang-v3
       - run: make wasi-libc
       - save_cache:
-          key: wasi-libc-sysroot-systemclang-v2
+          key: wasi-libc-sysroot-systemclang-v3
           paths:
             - lib/wasi-libc/sysroot
-      - run: go test -v -tags=llvm<<parameters.llvm>> ./cgo ./compileopts ./interp ./transform .
+      - run:
+          name: "Test TinyGo"
+          command: go test -v -timeout=20m -tags=llvm<<parameters.llvm>> ./builder ./cgo ./compileopts ./compiler ./interp ./transform .
+          no_output_timeout: 20m
       - run: make gen-device -j4
       - run: make smoketest XTENSA=0
       - run: make tinygo-test
@@ -132,16 +135,13 @@ commands:
       - run:
           name: "Install apt dependencies"
           command: |
-            sudo apt-get install \
-                gcc-arm-linux-gnueabihf \
-                libc6-dev-armel-cross \
-                gcc-aarch64-linux-gnu \
-                libc6-dev-arm64-cross \
+            sudo apt-get update
+            sudo apt-get install --no-install-recommends \
+                libgnutls30 libssl1.0.2 \
                 qemu-system-arm \
                 qemu-user \
                 gcc-avr \
                 avr-libc
-            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-6-dev
       - install-node
       - install-wasmtime
       - install-xtensa-toolchain:
@@ -153,12 +153,15 @@ commands:
       - llvm-source-linux
       - restore_cache:
           keys:
-            - llvm-build-11-linux-v1-assert
+            - llvm-build-11-linux-v4-assert
       - run:
           name: "Build LLVM"
           command: |
             if [ ! -f llvm-build/lib/liblldELF.a ]
             then
+              # fetch LLVM source
+              rm -rf llvm-project
+              make llvm-source
               # install dependencies
               sudo apt-get install cmake ninja-build
               # hack ninja to use less jobs
@@ -166,9 +169,10 @@ commands:
               chmod +x /go/bin/ninja
               # build!
               make ASSERT=1 llvm-build
+              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
             fi
       - save_cache:
-          key: llvm-build-11-linux-v1-assert
+          key: llvm-build-11-linux-v4-assert
           paths:
             llvm-build
       - run: make ASSERT=1
@@ -176,6 +180,12 @@ commands:
       - run:
           name: "Test TinyGo"
           command: make ASSERT=1 test
+          no_output_timeout: 20m
+          environment:
+            # Note: -p=2 limits parallelism to two jobs at a time, which is
+            # necessary to keep memory consumption down and avoid OOM (for a
+            # 2CPU/4GB executor).
+            GOFLAGS: -p=2
       - save_cache:
           key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
           paths:
@@ -190,16 +200,13 @@ commands:
       - run:
           name: "Install apt dependencies"
           command: |
-            sudo apt-get install \
-                gcc-arm-linux-gnueabihf \
-                libc6-dev-armel-cross \
-                gcc-aarch64-linux-gnu \
-                libc6-dev-arm64-cross \
+            sudo apt-get update
+            sudo apt-get install --no-install-recommends \
+                libgnutls30 libssl1.0.2 \
                 qemu-system-arm \
                 qemu-user \
                 gcc-avr \
                 avr-libc
-            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-6-dev
       - install-node
       - install-wasmtime
       - install-xtensa-toolchain:
@@ -211,12 +218,15 @@ commands:
       - llvm-source-linux
       - restore_cache:
           keys:
-            - llvm-build-11-linux-v1-noassert
+            - llvm-build-11-linux-v4-noassert
       - run:
           name: "Build LLVM"
           command: |
             if [ ! -f llvm-build/lib/liblldELF.a ]
             then
+              # fetch LLVM source
+              rm -rf llvm-project
+              make llvm-source
               # install dependencies
               sudo apt-get install cmake ninja-build
               # hack ninja to use less jobs
@@ -224,15 +234,17 @@ commands:
               chmod +x /go/bin/ninja
               # build!
               make llvm-build
+              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
             fi
       - save_cache:
-          key: llvm-build-11-linux-v1-noassert
+          key: llvm-build-11-linux-v4-noassert
           paths:
             llvm-build
       - build-wasi-libc
       - run:
           name: "Test TinyGo"
           command: make test
+          no_output_timeout: 20m
       - run:
           name: "Install fpm"
           command: |
@@ -268,56 +280,64 @@ commands:
       - run:
           name: "Install dependencies"
           command: |
-            curl https://dl.google.com/go/go1.15.5.darwin-amd64.tar.gz -o go1.15.5.darwin-amd64.tar.gz
-            sudo tar -C /usr/local -xzf go1.15.5.darwin-amd64.tar.gz
+            curl https://dl.google.com/go/go1.17.darwin-amd64.tar.gz -o go1.17.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.17.darwin-amd64.tar.gz
             ln -s /usr/local/go/bin/go /usr/local/bin/go
             HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu
       - install-xtensa-toolchain:
           variant: "macos"
       - restore_cache:
           keys:
-            - go-cache-macos-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
-            - go-cache-macos-v2-{{ checksum "go.mod" }}
+            - go-cache-macos-v3-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-macos-v3-{{ checksum "go.mod" }}
       - restore_cache:
           keys:
-            - llvm-source-11-macos-v1
+            - llvm-source-11-macos-v3
       - run:
           name: "Fetch LLVM source"
           command: make llvm-source
       - save_cache:
-          key: llvm-source-11-macos-v1
+          key: llvm-source-11-macos-v3
           paths:
-            - llvm-project
+            - llvm-project/clang/lib/Headers
+            - llvm-project/clang/include
+            - llvm-project/lld/include
+            - llvm-project/llvm/include
       - restore_cache:
           keys:
-            - llvm-build-11-macos-v1
+            - llvm-build-11-macos-v5
       - run:
           name: "Build LLVM"
           command: |
             if [ ! -f llvm-build/lib/liblldELF.a ]
             then
+              # fetch LLVM source
+              rm -rf llvm-project
+              make llvm-source
               # install dependencies
               HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake ninja
               # build!
               make llvm-build
+              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
             fi
       - save_cache:
-          key: llvm-build-11-macos-v1
+          key: llvm-build-11-macos-v5
           paths:
             llvm-build
       - restore_cache:
           keys:
-            - wasi-libc-sysroot-macos-v2
+            - wasi-libc-sysroot-macos-v4
       - run:
           name: "Build wasi-libc"
           command: make wasi-libc
       - save_cache:
-          key: wasi-libc-sysroot-macos-v2
+          key: wasi-libc-sysroot-macos-v4
           paths:
             - lib/wasi-libc/sysroot
       - run:
           name: "Test TinyGo"
           command: make test
+          no_output_timeout: 20m
       - run:
           name: "Build TinyGo release"
           command: |
@@ -334,55 +354,37 @@ commands:
             tinygo version
       - run: make smoketest AVR=0
       - save_cache:
-          key: go-cache-macos-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          key: go-cache-macos-v3-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
           paths:
             - ~/.cache/go-build
             - /go/pkg/mod
 
 jobs:
-  test-llvm9-go111:
-    docker:
-      - image: circleci/golang:1.11-buster
-    steps:
-      - test-linux:
-          llvm: "9"
-  test-llvm10-go112:
-    docker:
-      - image: circleci/golang:1.12-buster
-    steps:
-      - test-linux:
-          llvm: "10"
-  test-llvm10-go113:
-    docker:
-      - image: circleci/golang:1.13-buster
-    steps:
-      - test-linux:
-          llvm: "10"
-  test-llvm10-go114:
-    docker:
-      - image: circleci/golang:1.14-buster
-    steps:
-      - test-linux:
-          llvm: "10"
   test-llvm11-go115:
     docker:
       - image: circleci/golang:1.15-buster
     steps:
       - test-linux:
           llvm: "11"
+  test-llvm11-go116:
+    docker:
+      - image: circleci/golang:1.16-buster
+    steps:
+      - test-linux:
+          llvm: "11"
   assert-test-linux:
     docker:
-      - image: circleci/golang:1.14-stretch
+      - image: circleci/golang:1.17-stretch
     steps:
       - assert-test-linux
   build-linux:
     docker:
-      - image: circleci/golang:1.14-stretch
+      - image: circleci/golang:1.17-stretch
     steps:
       - build-linux
   build-macos:
     macos:
-      xcode: "10.1.0"
+      xcode: "11.1.0" # macOS 10.14
     steps:
       - build-macos
 
@@ -391,11 +393,8 @@ jobs:
 workflows:
   test-all:
     jobs:
-      - test-llvm9-go111
-      - test-llvm10-go112
-      - test-llvm10-go113
-      - test-llvm10-go114
       - test-llvm11-go115
+      - test-llvm11-go116
       - build-linux
       - build-macos
       - assert-test-linux

.dockerignore

@@ -0,0 +1,3 @@
+build/
+llvm-*/
+

.github/workflows/build-tinygo-dev-docker.yml

@@ -0,0 +1,45 @@
+name: CI for tinygo-dev docker container
+on:
+  push:
+    branches: [ dev, fix-docker-llvm-build ]
+
+jobs:
+  push_to_registry:
+    name: Push Docker image to GHCR/Docker Hub
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v3
+        with:
+          images: |
+            tinygo/tinygo-dev
+            ghcr.io/${{ github.repository }}/tinygo-dev
+          tags: |
+            type=sha,format=long
+            type=raw,value=latest
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+      - name: Log in to Github Container Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/windows.yml

@@ -0,0 +1,85 @@
+name: Windows
+
+on: push
+
+jobs:
+  build-windows:
+    runs-on: windows-2016
+    steps:
+      - name: Install Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: '1.17'
+      - name: Install QEMU
+        shell: bash
+        run: |
+          choco install qemu --version=2020.06.12
+          echo "C:\Program Files\QEMU" >> $GITHUB_PATH
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          submodules: true
+      - name: Cache LLVM source
+        uses: actions/cache@v2
+        id: cache-llvm-source
+        with:
+          key: llvm-source-11-windows-v1
+          path: |
+            llvm-project/clang/lib/Headers
+            llvm-project/clang/include
+            llvm-project/lld/include
+            llvm-project/llvm/include
+      - name: Download LLVM source
+        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
+        run: make llvm-source
+      - name: Cache LLVM build
+        uses: actions/cache@v2
+        id: cache-llvm-build
+        with:
+          key: llvm-build-11-windows-v2
+          path: llvm-build
+      - name: Build LLVM
+        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
+        shell: bash
+        run: |
+          # fetch LLVM source
+          rm -rf llvm-project
+          make llvm-source
+          # install dependencies
+          choco install ninja
+          # build!
+          make llvm-build
+          # Remove unnecessary object files (to reduce cache size).
+          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+      - name: Cache wasi-libc sysroot
+        uses: actions/cache@v2
+        id: cache-wasi-libc
+        with:
+          key: wasi-libc-sysroot-v1
+          path: lib/wasi-libc/sysroot
+      - name: Build wasi-libc
+        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
+        run: make wasi-libc
+      - name: Test TinyGo
+        shell: bash
+        run: make test
+      - name: Build TinyGo release tarball
+        run: make build/release -j4
+      - name: Make release artifact
+        shell: bash
+        working-directory: build/release
+        run: 7z -tzip a release.zip tinygo
+      - name: Publish release artifact
+        # Note: this release artifact is double-zipped, see:
+        # https://github.com/actions/upload-artifact/issues/39
+        # We can essentially pick one of these:
+        # - have a dobule-zipped artifact when downloaded from the UI
+        # - have a very slow artifact upload
+        # We're doing the former here, to keep artifact uploads fast.
+        uses: actions/upload-artifact@v2
+        with:
+          name: release-double-zipped
+          path: build/release/release.zip
+      - name: Smoke tests
+        shell: bash
+        run: make smoketest TINYGO=build/tinygo AVR=0 XTENSA=0

.gitignore

@@ -16,6 +16,15 @@ src/device/stm32/*.go
 src/device/stm32/*.s
 src/device/kendryte/*.go
 src/device/kendryte/*.s
+src/device/rp/*.go
+src/device/rp/*.s
 vendor
 llvm-build
 llvm-project
+
+# Ignore files generated by smoketest
+test.gba
+test.hex
+test.nro
+test.wasm
+wasm.wasm

.gitmodules

@@ -20,3 +20,9 @@
 [submodule "lib/picolibc"]
 	path = lib/picolibc
 	url = https://github.com/keith-packard/picolibc.git
+[submodule "lib/stm32-svd"]
+	path = lib/stm32-svd
+	url = https://github.com/tinygo-org/stm32-svd
+[submodule "lib/musl"]
+	path = lib/musl
+	url = git://git.musl-libc.org/musl

BUILDING.md

@@ -23,7 +23,7 @@ different guide:
 LLVM, Clang and LLD are quite light on dependencies, requiring only standard
 build tools to be built. Go is of course necessary to build TinyGo itself.
 
-  * Go (1.11+)
+  * Go (1.15+)
   * Standard build tools (gcc/clang)
   * git
   * CMake
@@ -43,11 +43,6 @@ 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.
 
-TinyGo uses Go modules, so if you clone TinyGo inside your GOPATH (and are using
-Go below 1.13), make sure that Go modules are enabled:
-
-    export GO111MODULE=on
-
 ## Build LLVM, Clang, LLD
 
 Before starting the build, you may want to set the following environment

CHANGELOG.md

@@ -1,3 +1,351 @@
+0.20.0
+---
+
+* **command line**
+  - add support for Go 1.17
+  - improve Go version detection
+  - add support for the Black Magic Probe (BMP)
+  - add a flag for creating cpu profiles
+* **compiler**
+  - `builder:` list libraries at the end of the linker command
+  - `builder:` strip debug information at link time instead of at compile time
+  - `builder:` add missing error check for `ioutil.TempFile()`
+  - `builder:` simplify running of jobs
+  - `compiler:` move LLVM math builtin support into the compiler
+  - `compiler:` move math aliases from the runtime to the compiler
+  - `compiler:` add aliases for many hashing packages
+  - `compiler:` add `*ssa.MakeSlice` bounds tests
+  - `compiler:` fix max possible slice
+  - `compiler:` add support for new language features of Go 1.17
+  - `compiler:` fix equally named structs in different scopes
+  - `compiler:` avoid zero-sized alloca in channel operations
+  - `interp:` don't ignore array indices for untyped objects
+  - `interp:` keep reverted package initializers in order
+  - `interp:` fix bug in compiler-time/run-time package initializers
+  - `loader:` fix panic in CGo files with syntax errors
+  - `transform:` improve GC stack slot pass to work around a bug
+* **standard library**
+  - `crypto/rand`: switch to `arc4random_buf`
+  - `math:` fix `math.Max` and `math.Min`
+  - `math/big`: fix undefined symbols error
+  - `net:` add MAC address implementation
+  - `os:` implement `os.Executable`
+  - `os:` add `SEEK_SET`, `SEEK_CUR`, and `SEEK_END`
+  - `reflect:` add StructField.IsExported method
+  - `runtime:` reset heapptr to heapStart after preinit()
+  - `runtime:` add `subsections_via_symbols` to assembly files on darwin
+  - `testing:` add subset implementation of Benchmark
+  - `testing:` test testing package using `tinygo test`
+  - `testing:` add support for the `-test.v` flag
+* **targets**
+  - `386:` bump minimum requirement to the Pentium 4
+  - `arm:` switch to Thumb instruction set on ARM
+  - `atsamd:` fix copy-paste error for atsamd21/51 calibTrim block
+  - `baremetal`,`wasm`: support command line params and environment variables
+  - `cortexm:` fix stack overflow because of unaligned stacks
+  - `esp32c3:` add support for the ESP32-C3 from Espressif
+  - `nrf52840:` fix ram size
+  - `nxpmk66f18:` fix a suspicious bitwise operation
+  - `rp2040:` add SPI support
+  - `rp2040:` add I2C support
+  - `rp2040:` add PWM implementation
+  - `rp2040:` add openocd configuration
+  - `stm32:` add support for PortMask* functions for WS2812 support
+  - `unix:` fix time base for time.Now()
+  - `unix:` check for mmap error and act accordingly
+  - `wasm:` override dlmalloc heap implementation from wasi-libc
+  - `wasm:` align heap to 16 bytes
+  - `wasm:` add support for the crypto/rand package
+* **boards**
+  - add `DefaultUART` to adafruit boards
+  - `arduino-mkrwifi1010:` add board definition for Arduino MKR WiFi 1010
+  - `arduino-mkrwifi1010:` fix pin definition of `NINA_RESETN`
+  - `feather-nrf52:` fix pin definition of uart
+  - `feather-rp2040:` add pin name definition
+  - `gameboy-advance:` fix ROM header
+  - `mdbt50qrx-uf2:` add Raytac MDBT50Q-RX Dongle with TinyUF2
+  - `nano-rp2040:` define `NINA_SPI` and fix wifinina pins
+  - `teensy40:` enable hardware UART reconfiguration, fix receive watermark interrupt
+
+
+0.19.0
+---
+
+* **command line**
+  - don't consider compile-only tests as failing
+  - add -test flag for `tinygo list`
+  - escape commands while printing them with the -x flag
+  - make flash-command portable and safer to use
+  - use `extended-remote` instead of `remote` in GDB
+  - detect specific serial port IDs based on USB vid/pid
+  - add a flag to the command line to select the serial implementation
+* **compiler**
+  - `cgo`: improve constant parser
+  - `compiler`: support chained interrupt handlers
+  - `compiler`: add support for running a builtin in a goroutine
+  - `compiler`: do not emit nil checks for loading closure variables
+  - `compiler`: skip context parameter when starting regular goroutine
+  - `compiler`: refactor method names
+  - `compiler`: add function and global section pragmas
+  - `compiler`: implement `syscall.rawSyscallNoError` in inline assembly
+  - `interp`: ignore inline assembly in markExternal
+  - `interp`: fix a bug in pointer cast workaround
+  - `loader`: fix testing a main package
+* **standard library**
+  - `crypto/rand`: replace this package with a TinyGo version
+  - `machine`: make USBCDC global a pointer
+  - `machine`: make UART objects pointer receivers
+  - `machine`: define Serial as the default output
+  - `net`: add initial support for net.IP
+  - `net`: add more net compatibility
+  - `os`: add stub for os.ReadDir
+  - `os`: add FileMode constants from Go 1.16
+  - `os`: add stubs required for net/http
+  - `os`: implement process related functions
+  - `reflect`: implement AppendSlice
+  - `reflect`: add stubs required for net/http
+  - `runtime`: make task.Data a 64-bit integer to avoid overflow
+  - `runtime`: expose memory stats
+  - `sync`: implement NewCond
+  - `syscall`: fix int type in libc version
+* **targets**
+  - `cortexm`: do not disable interrupts on abort
+  - `cortexm`: bump default stack size to 2048 bytes
+  - `nrf`: avoid heap allocation in waitForEvent
+  - `nrf`: don't trigger a heap allocation in SPI.Transfer
+  - `nrf52840`: add support for flashing with the BOSSA tool
+  - `rp2040`: add support for GPIO input
+  - `rp2040`: add basic support for ADC
+  - `rp2040`: gpio and adc pin definitions
+  - `rp2040`: implement UART
+  - `rp2040`: patch elf to checksum 2nd stage boot
+  - `stm32`: add PWM for most chips
+  - `stm32`: add support for pin interrupts
+  - `stm32f103`: add support for PinInputPullup / PinInputPulldown
+  - `wasi`: remove wasm build tag
+* **boards**
+  - `feather-rp2040`: add support for this board
+  - `feather-nrf52840-sense`: add board definition for this board
+  - `pca10059`: support flashing from Windows
+  - `nano-rp2040`: add this board
+  - `nano-33-ble`: add support for this board
+  - `pico`: add the Raspberry Pi Pico board with the new RP2040 chip
+  - `qtpy`: add pin for neopixels
+  - all: add definition for ws2812 for supported boards
+
+
+0.18.0
+---
+
+* **command line**
+  - drop support for Go 1.11 and 1.12
+  - throw an error when no target is specified on Windows
+  - improve error messages in `getDefaultPort()`, support for multiple ports
+  - remove `-cflags` and `-ldflags` flags
+  - implement `-ldflags="-X ..."`
+  - add `-print-allocs` flag that lets you print all heap allocations
+  - openocd commands in tinygo command line
+  - add `-llvm-features` parameter
+  - match `go test` output
+  - discover USB ports only, this will ignore f.ex. bluetooth
+  - use physicmal path instead of cached GOROOT in function getGoroot
+  - add goroot for snap installs
+* **compiler**
+  - `builder`: add support for `-opt=0`
+  - `builder`, `compiler`: compile and cache packages in parallel
+  - `builder`: run interp per package
+  - `builder`: cache C and assembly file outputs
+  - `builder`: add support for `-x` flag to print commands
+  - `builder`: add optsize attribute while building the package
+  - `builder`: run function passes per package
+  - `builder`: hard code Clang compiler
+  - `compiler`: do not use `llvm.GlobalContext()`
+  - `compiler`: remove SimpleDCE pass
+  - `compiler`: do not emit nil checks for `*ssa.Alloc` instructions
+  - `compiler`: merge `runtime.typecodeID` and runtime.typeInInterface
+  - `compiler`: do not check for impossible type asserts
+  - `compiler`: fix use of global context: `llvm.Int32Type()`
+  - `compiler`: add interface IR test
+  - `compiler`: fix lack of method name in interface matching
+  - `compiler`: fix "fragment covers entire variable" bug
+  - `compiler`: optimize string literals and globals
+  - `compiler`: decouple func lowering from interface type codes
+  - `compiler`: add function attributes to some runtime calls
+  - `compiler`: improve position information in error messages
+  - `cgo`: add support for CFLAGS in .c files
+  - `interp`: support GEP on fixed (MMIO) addresses
+  - `interp`: handle `(reflect.Type).Elem()`
+  - `interp`: add support for runtime.interfaceMethod
+  - `interp`: make toLLVMValue return an error instead of panicking
+  - `interp`: add support for switch statement
+  - `interp`: fix phi instruction
+  - `interp`: remove map support
+  - `interp`: support extractvalue/insertvalue with multiple operands
+  - `transform`: optimize string comparisons against ""
+  - `transform`: optimize `reflect.Type` `Implements()` method
+  - `transform`: fix bug in interface lowering when signatures are renamed
+  - `transform`: don't rely on struct name of `runtime.typecodeID`
+  - `transform`: use IPSCCP pass instead of the constant propagation pass
+  - `transform`: fix func lowering assertion failure
+  - `transform`: do not lower zero-sized alloc to alloca
+  - `transform`: split interface and reflect lowering
+* **standard library**
+  - `runtime`: add dummy debug package
+  - `machine`: fix data shift/mask in newUSBSetup
+  - `machine`: make `machine.I2C0` and similar objects pointers
+  - `machine`: unify usbcdc code
+  - `machine`: refactor PWM support
+  - `machine`: avoid heap allocations in USB code
+  - `reflect`: let `reflect.Type` be of interface type
+  - `reflect`: implement a number of stub functions
+  - `reflect`: check for access in the `Interface` method call
+  - `reflect`: fix `AssignableTo` and `Implements` methods
+  - `reflect`: implement `Value.CanAddr`
+  - `reflect`: implement `Sizeof` and `Alignof` for func values
+  - `reflect`: implement `New` function
+  - `runtime`: implement command line arguments in hosted environments
+  - `runtime`: implement environment variables for Linux
+  - `runtime`: improve timers on nrf, and samd chips
+* **targets**
+  - all: use -Qunused-arguments only for assembly files
+  - `atmega1280`: add PWM support
+  - `attiny`: remove dummy UART
+  - `atsamd21`: improve SPI
+  - `atsamd51`: fix PWM support in atsamd51p20
+  - `atsamd5x`: improve SPI
+  - `atsamd51`, `atsame5x`: unify samd51 and same5x
+  - `atsamd51`, `atsamd21`: fix `ADC.Get()` value at 8bit and 10bit
+  - `atsame5x`: add support for CAN
+  - `avr`: remove I2C stubs from attiny support
+  - `cortexm`: check for `arm-none-eabi-gdb` and `gdb-multiarch` commands
+  - `cortexm`: add `__isr_vector` symbol
+  - `cortexm`: disable FPU on Cortex-M4
+  - `cortexm`: clean up Cortex-M target files
+  - `fe310`: fix SPI read
+  - `gameboy-advance`: Fix RGBA color interpretation
+  - `nrf52833`: add PWM support
+  - `stm32l0`: use unified UART logic
+  - `stm32`: move f103 (bluepill) to common i2c code
+  - `stm32`: separate altfunc selection for UART Tx/Rx
+  - `stm32`: i2c implementation for F7, L5 and L4 MCUs
+  - `stm32`: make SPI CLK fast to fix data issue
+  - `stm32`: support SPI on L4 series
+  - `unix`: avoid possible heap allocation with `-opt=0`
+  - `unix`: use conservative GC by default
+  - `unix`: use the tasks scheduler instead of coroutines
+  - `wasi`: upgrade WASI version to wasi_snapshot_preview1
+  - `wasi`: darwin: support basic file io based on libc
+  - `wasm`: only export explicitly exported functions
+  - `wasm`: use WASI ABI for exit function
+  - `wasm`: scan globals conservatively
+* **boards**
+  - `arduino-mega1280`: add support for the Arduino Mega 1280
+  - `arduino-nano-new`: Add Arduino Nano w/ New Bootloader target
+  - `atsame54-xpro`: add initial support this board
+  - `feather-m4-can`: add initial support for this board
+  - `grandcentral-m4`: add board support for Adafruit Grand Central M4 (SAMD51)
+  - `lgt92`: update to new UART structure
+  - `microbit`: remove LED constant
+  - `microbit-v2`: add support for S113 SoftDevice
+  - `nucleol432`: add support for this board
+  - `nucleo-l031k6`: add this board
+  - `pca10059`: initial support for this board
+  - `qtpy`: fix msd-volume-name
+  - `qtpy`: fix i2c setting
+  - `teensy40`: move txBuffer allocation to UART declaration
+  - `teensy40`: add UART0 as alias for UART1
+
+
+0.17.0
+
+---
+* **command line**
+  - switch to LLVM 11 for static builds
+  - support gdb debugging with AVR
+  - add support for additional openocd commands
+  - add `-x` flag to print commands
+  - use LLVM 11 by default when linking LLVM dynamically
+  - update go-llvm to use LLVM 11 on macOS
+  - bump go.bug.st/serial to version 1.1.2
+  - do not build LLVM with libxml to work around a bugo on macOS
+  - add support for Go 1.16
+  - support gdb daemonization on Windows
+  - remove support for LLVM 9, to fix CI
+  - kill OpenOCD if it does not exit with a regular quit signal
+  - support `-ocd-output` on Windows
+* **compiler**
+  - `builder`: parallelize most of the build
+  - `builder`: remove unused cacheKey parameter
+  - `builder`: add -mcpu flag while building libraries
+  - `builder`: wait for running jobs to finish
+  - `cgo`: add support for variadic functions
+  - `compiler`: fix undefined behavior in wordpack
+  - `compiler`: fix incorrect "exported function" panic
+  - `compiler`: fix non-int integer constants (fixing a crash)
+  - `compiler`: refactor and add tests
+  - `compiler`: emit a nil check when slicing an array pointer
+  - `compiler`: saturate float-to-int conversions
+  - `compiler`: test float to int conversions and fix upper-bound calculation
+  - `compiler`: support all kinds of deferred builtins
+  - `compiler`: remove ir package
+  - `compiler`: remove unnecessary main.main call workaround
+  - `compiler`: move the setting of attributes to getFunction
+  - `compiler`: create runtime types lazily when needed
+  - `compiler`: move settings to a separate Config struct
+  - `compiler`: work around an ARM backend bug in LLVM
+  - `interp`: rewrite entire package
+  - `interp`: fix alignment of untyped globals
+  - `loader`: use name "main" for the main package
+  - `loader`: support imports from vendor directories
+  - `stacksize`: add support for DW_CFA_offset_extended
+  - `transform`: show better error message in coroutines lowering
+* **standard library**
+  - `machine`: accept configuration struct for ADC parameters
+  - `machine`: make I2C.Configure signature consistent
+  - `reflect`: implement PtrTo
+  - `runtime`: refactor to simplify stack switching
+  - `runtime`: put metadata at the top end of the heap
+* **targets**
+  - `atsam`: add a length check to findPinPadMapping
+  - `atsam`: improve USBCDC
+  - `atsam`: avoid infinite loop when USBCDC is disconnected
+  - `avr`: add SPI support for Atmega based chips
+  - `avr`: use Clang for compiling C and assembly files
+  - `esp32`: implement task based scheduler
+  - `esp32`: enable the FPU
+  - `esp8266`: implement task based scheduler
+  - `esp`: add compiler-rt library
+  - `esp`: add picolibc
+  - `nrf`: refactor code a bit to reduce duplication
+  - `nrf`: use SPIM peripheral instead of the legacy SPI peripheral
+  - `nrf`: update nrfx submodule to latest commit
+  - `nrf52840`: ensure that USB CDC interface is only initialized once
+  - `nrf52840`: improve USBCDC
+  - `stm32`: use stm32-rs SVDs which are of much higher quality
+  - `stm32`: harmonization of UART logic
+  - `stm32`: replace I2C addressable interface with simpler type
+  - `stm32`: fix i2c and add stm32f407 i2c
+  - `stm32`: revert change that adds support for channels in interrupts
+  - `wasm`: implement a growable heap
+  - `wasm`: fix typo in wasm_exec.js, syscall/js.valueLoadString()
+  - `wasm`: Namespaced Wasm Imports so they don't conflict across modules, or reserved LLVM IR
+  - `wasi`: support env variables based on libc
+  - `wasi`: specify wasi-libc in a different way, to improve error message
+* **boards**
+  - `matrixportal-m4`: add support for board Adafruit Matrix Portal M4
+  - `mkr1000`: add this board
+  - `nucleo-f722ze`: add this board
+  - `clue`: correct volume name and add alias for release version of Adafruit Clue board
+  - `p1am-100`: add support for the P1AM-100 (similar to Arduino MKR)
+  - `microbit-v2`: add initial support based on work done by @alankrantas thank you!
+  - `lgt92`: support for STM32L0 MCUs and Dragino LGT92 device
+  - `nicenano`: nice!nano board support
+  - `circuitplay-bluefruit`: correct internal I2C pin mapping
+  - `clue`: correct for lack of low frequency crystal
+  - `digispark`: split off attiny85 target
+  - `nucleo-l552ze`: implementation with CLOCK, LED, and UART
+  - `nrf52840-mdk-usb-dongle`: add this board
+
 0.16.0
 ---
 

Dockerfile

@@ -1,10 +1,10 @@
-# TinyGo base stage installs the most recent Go 1.15.x, LLVM 10 and the TinyGo compiler itself.
-FROM golang:1.15 AS tinygo-base
+# TinyGo base stage installs the most recent Go 1.17.x, LLVM 11 and the TinyGo compiler itself.
+FROM golang:1.17 AS tinygo-base
 
 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
-    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/bullseye/ llvm-toolchain-bullseye-11 main" >> /etc/apt/sources.list && \
     apt-get update && \
-    apt-get install -y llvm-10-dev libclang-10-dev lld-10 git
+    apt-get install -y llvm-11-dev libclang-11-dev lld-11 git
 
 COPY . /tinygo
 
@@ -15,7 +15,7 @@ RUN cd /tinygo/ && \
     git submodule sync && \
     git submodule update --init --recursive --force
 
-COPY ./lib/picolibc-include/* /tinygo/lib/picolibc-include/
+COPY ./lib/picolibc-stdio.c /tinygo/lib/picolibc-stdio.c
 
 RUN cd /tinygo/ && \
     go install /tinygo/
@@ -29,7 +29,7 @@ COPY --from=tinygo-base /tinygo/targets /tinygo/targets
 
 RUN cd /tinygo/ && \
     apt-get update && \
-    apt-get install -y make clang-10 libllvm10 lld-10 && \
+    apt-get install -y make clang-11 libllvm11 lld-11 && \
     make wasi-libc
 
 # tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
@@ -61,7 +61,7 @@ COPY --from=tinygo-base /tinygo/lib /tinygo/lib
 
 RUN cd /tinygo/ && \
     apt-get update && \
-    apt-get install -y apt-utils make clang-10 && \
+    apt-get install -y apt-utils make clang-11 && \
     make gen-device-nrf && make gen-device-stm32
 
 # tinygo-all stage installs the needed dependencies to compile TinyGo programs for all platforms.
@@ -73,7 +73,7 @@ COPY --from=tinygo-base /tinygo/lib /tinygo/lib
 
 RUN cd /tinygo/ && \
     apt-get update && \
-    apt-get install -y apt-utils make clang-10 binutils-avr gcc-avr avr-libc && \
+    apt-get install -y apt-utils make clang-11 binutils-avr gcc-avr avr-libc && \
     make gen-device
 
 CMD ["tinygo"]

LICENSE

@@ -1,7 +1,7 @@
-Copyright (c) 2018-2020 TinyGo Authors. All rights reserved.
+Copyright (c) 2018-2021 TinyGo Authors. All rights reserved.
 
 TinyGo includes portions of the Go standard library.
-Copyright (c) 2009-2020 The Go Authors. All rights reserved.
+Copyright (c) 2009-2021 The Go Authors. All rights reserved.
 
 TinyGo includes portions of LLVM, which is under the Apache License v2.0 with
 LLVM Exceptions. See https://llvm.org/LICENSE.txt for license information.

Makefile

@@ -10,9 +10,9 @@ LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
 
 # Try to autodetect LLVM build tools.
 detect = $(shell command -v $(1) 2> /dev/null && echo $(1))
-CLANG ?= $(word 1,$(abspath $(call detect,llvm-build/bin/clang))$(call detect,clang-11)$(call detect,clang-10)$(call detect,clang))
-LLVM_AR ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-ar))$(call detect,llvm-ar-11)$(call detect,llvm-ar-10)$(call detect,llvm-ar))
-LLVM_NM ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-nm))$(call detect,llvm-nm-11)$(call detect,llvm-nm-10)$(call detect,llvm-nm))
+CLANG ?= $(word 1,$(abspath $(call detect,llvm-build/bin/clang))$(call detect,clang-11)$(call detect,clang))
+LLVM_AR ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-ar))$(call detect,llvm-ar-11)$(call detect,llvm-ar))
+LLVM_NM ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-nm))$(call detect,llvm-nm-11)$(call detect,llvm-nm))
 
 # Go binary and GOROOT to select
 GO ?= go
@@ -36,7 +36,7 @@ else
     LLVM_OPTION += '-DLLVM_ENABLE_ASSERTIONS=OFF'
 endif
 
-.PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-nxp gen-device-avr
+.PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-nxp gen-device-avr gen-device-rp
 
 LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines coverage debuginfodwarf executionengine frontendopenmp instrumentation interpreter ipo irreader linker lto mc mcjit objcarcopts option profiledata scalaropts support target
 
@@ -54,46 +54,63 @@ ifeq ($(OS),Windows_NT)
     CGO_LDFLAGS += -static -static-libgcc -static-libstdc++
     CGO_LDFLAGS_EXTRA += -lversion
 
-    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/liblibclang.a
+    LIBCLANG_NAME = libclang
 
 else ifeq ($(shell uname -s),Darwin)
     MD5SUM = md5
-    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
+    LIBCLANG_NAME = clang
 else ifeq ($(shell uname -s),FreeBSD)
     MD5SUM = md5
-    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
+    LIBCLANG_NAME = clang
     START_GROUP = -Wl,--start-group
     END_GROUP = -Wl,--end-group
 else
-    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
+    LIBCLANG_NAME = clang
     START_GROUP = -Wl,--start-group
     END_GROUP = -Wl,--end-group
 endif
 
-CLANG_LIBS = $(START_GROUP) -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 $(END_GROUP) -lstdc++
+# Libraries that should be linked in for the statically linked Clang.
+CLANG_LIB_NAMES = clangAnalysis clangAST clangASTMatchers clangBasic clangCodeGen clangCrossTU clangDriver clangDynamicASTMatchers clangEdit clangFormat clangFrontend clangFrontendTool clangHandleCXX clangHandleLLVM clangIndex clangLex clangParse clangRewrite clangRewriteFrontend clangSema clangSerialization clangTooling clangToolingASTDiff clangToolingCore clangToolingInclusions
+CLANG_LIBS = $(START_GROUP) $(addprefix -l,$(CLANG_LIB_NAMES)) $(END_GROUP) -lstdc++
 
-LLD_LIBS = $(START_GROUP) -llldCOFF -llldCommon -llldCore -llldDriver -llldELF -llldMachO -llldMinGW -llldReaderWriter -llldWasm -llldYAML $(END_GROUP)
+# Libraries that should be linked in for the statically linked LLD.
+LLD_LIB_NAMES = lldCOFF lldCommon lldCore lldDriver lldELF lldMachO lldMinGW lldReaderWriter lldWasm lldYAML
+LLD_LIBS = $(START_GROUP) $(addprefix -l,$(LLD_LIB_NAMES)) $(END_GROUP)
 
+# Other libraries that are needed to link TinyGo.
+EXTRA_LIB_NAMES = LLVMInterpreter
+
+# These build targets appear to be the only ones necessary to build all TinyGo
+# dependencies. Only building a subset significantly speeds up rebuilding LLVM.
+# The Makefile rules convert a name like lldELF to lib/liblldELF.a to match the
+# library path (for ninja).
+# This list also includes a few tools that are necessary as part of the full
+# TinyGo build.
+NINJA_BUILD_TARGETS = clang llvm-config llvm-ar llvm-nm $(addprefix lib/lib,$(addsuffix .a,$(LIBCLANG_NAME) $(CLANG_LIB_NAMES) $(LLD_LIB_NAMES) $(EXTRA_LIB_NAMES)))
 
 # For static linking.
 ifneq ("$(wildcard $(LLVM_BUILDDIR)/bin/llvm-config*)","")
     CGO_CPPFLAGS+=$(shell $(LLVM_BUILDDIR)/bin/llvm-config --cppflags) -I$(abspath $(LLVM_BUILDDIR))/tools/clang/include -I$(abspath $(CLANG_SRC))/include -I$(abspath $(LLD_SRC))/include
     CGO_CXXFLAGS=-std=c++14
-    CGO_LDFLAGS+=$(LIBCLANG_PATH) -L$(abspath $(LLVM_BUILDDIR)/lib) $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS)) -lstdc++ $(CGO_LDFLAGS_EXTRA)
+    CGO_LDFLAGS+=$(abspath $(LLVM_BUILDDIR))/lib/lib$(LIBCLANG_NAME).a -L$(abspath $(LLVM_BUILDDIR)/lib) $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS)) -lstdc++ $(CGO_LDFLAGS_EXTRA)
 endif
 
 
 clean:
 	@rm -rf build
 
-FMT_PATHS = ./*.go builder cgo compiler interp ir loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/internal/reflectlite transform
+FMT_PATHS = ./*.go builder cgo compiler interp loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/testing src/internal/reflectlite transform
 fmt:
 	@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-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-stm32 gen-device-kendryte gen-device-nxp
+gen-device: gen-device-avr gen-device-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-kendryte gen-device-nxp gen-device-rp
+ifneq ($(STM32), 0)
+gen-device: gen-device-stm32
+endif
 
 gen-device-avr:
 	@if [ ! -e lib/avr/README.md ]; then echo "Submodules have not been downloaded. Please download them using:\n  git submodule update --init"; exit 1; fi
@@ -107,6 +124,7 @@ build/gen-device-svd: ./tools/gen-device-svd/*.go
 
 gen-device-esp: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Espressif-Community -interrupts=software lib/cmsis-svd/data/Espressif-Community/ src/device/esp/
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Espressif -interrupts=software lib/cmsis-svd/data/Espressif/ src/device/esp/
 	GO111MODULE=off $(GO) fmt ./src/device/esp
 
 gen-device-nrf: build/gen-device-svd
@@ -130,23 +148,26 @@ gen-device-kendryte: build/gen-device-svd
 	GO111MODULE=off $(GO) fmt ./src/device/kendryte
 
 gen-device-stm32: build/gen-device-svd
-	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/STMicro lib/cmsis-svd/data/STMicro/ src/device/stm32/
+	./build/gen-device-svd -source=https://github.com/tinygo-org/stm32-svd lib/stm32-svd/svd src/device/stm32/
 	GO111MODULE=off $(GO) fmt ./src/device/stm32
 
+gen-device-rp: build/gen-device-svd
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/RaspberryPi lib/cmsis-svd/data/RaspberryPi/ src/device/rp/
+	GO111MODULE=off $(GO) fmt ./src/device/rp
 
 # Get LLVM sources.
-$(LLVM_PROJECTDIR)/README.md:
+$(LLVM_PROJECTDIR)/llvm:
 	git clone -b xtensa_release_11.0.0 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
-llvm-source: $(LLVM_PROJECTDIR)/README.md
+llvm-source: $(LLVM_PROJECTDIR)/llvm
 
 # Configure LLVM.
 TINYGO_SOURCE_DIR=$(shell pwd)
 $(LLVM_BUILDDIR)/build.ninja: llvm-source
-	mkdir -p $(LLVM_BUILDDIR); cd $(LLVM_BUILDDIR); cmake -G Ninja $(TINYGO_SOURCE_DIR)/$(LLVM_PROJECTDIR)/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR;Xtensa" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_LIBEDIT=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DLLVM_ENABLE_OCAMLDOC=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF $(LLVM_OPTION)
+	mkdir -p $(LLVM_BUILDDIR); cd $(LLVM_BUILDDIR); cmake -G Ninja $(TINYGO_SOURCE_DIR)/$(LLVM_PROJECTDIR)/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR;Xtensa" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_LIBEDIT=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DLLVM_ENABLE_OCAMLDOC=OFF -DLLVM_ENABLE_LIBXML2=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF -DCLANG_ENABLE_STATIC_ANALYZER=OFF -DCLANG_ENABLE_ARCMT=OFF $(LLVM_OPTION)
 
 # Build LLVM.
 $(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
-	cd $(LLVM_BUILDDIR); ninja
+	cd $(LLVM_BUILDDIR); ninja $(NINJA_BUILD_TARGETS)
 
 
 # Build wasi-libc sysroot
@@ -154,7 +175,7 @@ $(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
 wasi-libc: lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a
 lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a:
 	@if [ ! -e lib/wasi-libc/Makefile ]; then echo "Submodules have not been downloaded. Please download them using:\n  git submodule update --init"; exit 1; fi
-	cd lib/wasi-libc && make -j4 WASM_CC=$(CLANG) WASM_AR=$(LLVM_AR) WASM_NM=$(LLVM_NM)
+	cd lib/wasi-libc && make -j4 WASM_CFLAGS="-O2 -g -DNDEBUG" WASM_CC=$(CLANG) WASM_AR=$(LLVM_AR) WASM_NM=$(LLVM_NM)
 
 
 # Build the Go compiler.
@@ -163,27 +184,44 @@ tinygo:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -buildmode exe -o build/tinygo$(EXE) -tags byollvm -ldflags="-X main.gitSha1=`git rev-parse --short HEAD`" .
 
 test: wasi-libc
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -buildmode exe -tags byollvm ./cgo ./compileopts ./interp ./transform .
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -timeout=20m -buildmode exe -tags byollvm ./builder ./cgo ./compileopts ./compiler ./interp ./transform .
+
+TEST_PACKAGES = \
+	compress/bzip2 \
+	container/heap \
+	container/list \
+	container/ring \
+	crypto/des \
+	crypto/dsa \
+	crypto/md5 \
+	crypto/rc4 \
+	crypto/sha1 \
+	crypto/sha256 \
+	crypto/sha512 \
+	encoding \
+	encoding/ascii85 \
+	encoding/base32 \
+	encoding/hex \
+	hash \
+	hash/adler32 \
+	hash/fnv \
+	hash/crc64 \
+	html \
+	index/suffixarray \
+	math \
+	math/cmplx \
+	testing \
+	testing/iotest \
+	text/scanner \
+	text/scanner \
+	unicode \
+	unicode/utf8 \
 
 # Test known-working standard library packages.
-# TODO: do this in one command, parallelize, and only show failing tests (no
-# implied -v flag).
+# TODO: parallelize, and only show failing tests (no implied -v flag).
 .PHONY: tinygo-test
 tinygo-test:
-	$(TINYGO) test container/heap
-	$(TINYGO) test container/list
-	$(TINYGO) test container/ring
-	$(TINYGO) test crypto/des
-	$(TINYGO) test encoding/ascii85
-	$(TINYGO) test encoding/base32
-	$(TINYGO) test encoding/hex
-	$(TINYGO) test hash/adler32
-	$(TINYGO) test hash/fnv
-	$(TINYGO) test hash/crc64
-	$(TINYGO) test math
-	$(TINYGO) test math/cmplx
-	$(TINYGO) test text/scanner
-	$(TINYGO) test unicode/utf8
+	$(TINYGO) test $(TEST_PACKAGES)
 
 .PHONY: smoketest
 smoketest:
@@ -207,6 +245,8 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/mcp3008
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/memstats
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=microbit            examples/microbit-blink
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/pininterrupt
@@ -218,17 +258,17 @@ smoketest:
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/test
 	@$(MD5SUM) test.hex
 	# test simulated boards on play.tinygo.org
-	$(TINYGO) build             -o test.wasm -tags=arduino              examples/blinky1
+	$(TINYGO) build -size short -o test.wasm -tags=arduino              examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build             -o test.wasm -tags=hifive1b             examples/blinky1
+	$(TINYGO) build -size short -o test.wasm -tags=hifive1b             examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build             -o test.wasm -tags=reelboard            examples/blinky1
+	$(TINYGO) build -size short -o test.wasm -tags=reelboard            examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build             -o test.wasm -tags=pca10040             examples/blinky2
+	$(TINYGO) build -size short -o test.wasm -tags=pca10040             examples/blinky2
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build             -o test.wasm -tags=pca10056             examples/blinky2
+	$(TINYGO) build -size short -o test.wasm -tags=pca10056             examples/blinky2
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build             -o test.wasm -tags=circuitplay_express  examples/blinky1
+	$(TINYGO) build -size short -o test.wasm -tags=circuitplay_express  examples/blinky1
 	@$(MD5SUM) test.wasm
 	# test all targets/boards
 	$(TINYGO) build -size short -o test.hex -target=pca10040-s132v6     examples/blinky1
@@ -237,12 +277,14 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=microbit-s110v8     examples/echo
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=microbit-v2         examples/microbit-blink
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=microbit-v2-s113v7  examples/microbit-blink
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=nrf52840-mdk        examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10031            examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=bluepill            examples/blinky1
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=reelboard           examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=reelboard           examples/blinky2
@@ -251,6 +293,10 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10056            examples/blinky2
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pca10059            examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pca10059            examples/blinky2
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m0          examples/blinky1
@@ -259,14 +305,6 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=stm32f4disco        examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=stm32f4disco        examples/blinky2
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=stm32f4disco-1      examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=feather-stm32f405   examples/blinky1
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=circuitplay-bluefruit examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/i2s
@@ -275,6 +313,8 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.gba -target=gameboy-advance     examples/gba-display
 	@$(MD5SUM) test.gba
+	$(TINYGO) build -size short -o test.hex -target=grandcentral-m4     examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m4        examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m4          examples/blinky1
@@ -291,8 +331,6 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=particle-xenon      examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=nucleo-f103rb       examples/blinky1
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pinetime-devkit0    examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=x9pro               examples/blinky1
@@ -313,15 +351,37 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-nrf52840  	examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=feather-nrf52840-sense examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-nrf52840  examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=qtpy  				examples/blinky1
+	$(TINYGO) build -size short -o test.hex -target=qtpy                examples/serial
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=teensy40            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=teensy36            examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=nucleo-f722ze       examples/blinky1
+	$(TINYGO) build -size short -o test.hex -target=p1am-100            examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=atsame54-xpro       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=atsame54-xpro       examples/can
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=feather-m4-can      examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=feather-m4-can      examples/caninterrupt
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-nano33      examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-mkrwifi1010 examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pico                examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nano-33-ble         examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nano-rp2040         examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=feather-rp2040 		examples/blinky1
 	@$(MD5SUM) test.hex
 	# test pwm
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/pwm
@@ -330,8 +390,32 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m4          examples/pwm
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pyportal            examples/pwm
+ifneq ($(STM32), 0)
+	$(TINYGO) build -size short -o test.hex -target=bluepill            examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=feather-stm32f405   examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=lgt92               examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nucleo-f103rb       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nucleo-f722ze       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nucleo-l031k6       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nucleo-l432kc       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nucleo-l552ze       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=stm32f4disco        examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=stm32f4disco        examples/blinky2
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=stm32f4disco-1      examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=stm32f4disco-1      examples/pwm
+	@$(MD5SUM) test.hex
+endif
 ifneq ($(AVR), 0)
 	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
 	@$(MD5SUM) test.hex
@@ -341,6 +425,10 @@ ifneq ($(AVR), 0)
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino -scheduler=tasks  examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-mega1280    examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-mega1280    examples/pwm
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino-nano        examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=digispark           examples/blinky1
@@ -353,22 +441,35 @@ ifneq ($(XTENSA), 0)
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target=nodemcu             examples/blinky1
 	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target m5stack-core2       examples/serial
+	@$(MD5SUM) test.bin
 endif
+	$(TINYGO) build -size short -o test.bin -target=esp32c3           	examples/serial
+	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.hex -target=hifive1b            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=hifive1-qemu        examples/serial
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=maixbit             examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/export
-	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/main
+	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/export
+	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/main
 	# test various compiler flags
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -gc=none -scheduler=none examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -opt=1     examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pca10040 -serial=none examples/echo
+	@$(MD5SUM) test.hex
 	$(TINYGO) build             -o test.nro -target=nintendoswitch      examples/serial
 	@$(MD5SUM) test.nro
+	$(TINYGO) build -size short -o test.hex -target=pca10040 -opt=0     ./testdata/stdlib.go
+	@$(MD5SUM) test.hex
+	GOOS=linux GOARCH=arm $(TINYGO) build -size short -o test.elf       ./testdata/cgo
+ifneq ($(OS),Windows_NT)
+	$(TINYGO) build -o test.elf -gc=leaking -scheduler=none examples/serial
+endif
+
 
 wasmtest:
 	$(GO) test ./tests/wasm
@@ -378,12 +479,16 @@ build/release: tinygo gen-device wasi-libc
 	@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/musl/arch
+	@mkdir -p build/release/tinygo/lib/musl/crt
+	@mkdir -p build/release/tinygo/lib/musl/src
 	@mkdir -p build/release/tinygo/lib/nrfx
 	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libc
+	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libm
 	@mkdir -p build/release/tinygo/lib/wasi-libc
-	@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
+	@mkdir -p build/release/tinygo/pkg/armv6m-unknown-unknown-eabi
+	@mkdir -p build/release/tinygo/pkg/armv7m-unknown-unknown-eabi
+	@mkdir -p build/release/tinygo/pkg/armv7em-unknown-unknown-eabi
 	@echo copying source files
 	@cp -p  build/tinygo$(EXE)           build/release/tinygo/bin
 	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
@@ -392,22 +497,44 @@ build/release: tinygo gen-device wasi-libc
 	@cp -rp lib/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt/lib
 	@cp -rp lib/compiler-rt/LICENSE.TXT  build/release/tinygo/lib/compiler-rt
 	@cp -rp lib/compiler-rt/README.txt   build/release/tinygo/lib/compiler-rt
+	@cp -rp lib/musl/arch/aarch64        build/release/tinygo/lib/musl/arch
+	@cp -rp lib/musl/arch/arm            build/release/tinygo/lib/musl/arch
+	@cp -rp lib/musl/arch/generic        build/release/tinygo/lib/musl/arch
+	@cp -rp lib/musl/arch/i386           build/release/tinygo/lib/musl/arch
+	@cp -rp lib/musl/arch/x86_64         build/release/tinygo/lib/musl/arch
+	@cp -rp lib/musl/crt/crt1.c          build/release/tinygo/lib/musl/crt
+	@cp -rp lib/musl/COPYRIGHT           build/release/tinygo/lib/musl
+	@cp -rp lib/musl/include             build/release/tinygo/lib/musl
+	@cp -rp lib/musl/src/env             build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/errno           build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/exit            build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/include         build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/internal        build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/malloc          build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/mman            build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/signal          build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/stdio           build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/string          build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/thread          build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/time            build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/unistd          build/release/tinygo/lib/musl/src
 	@cp -rp lib/nrfx/*                   build/release/tinygo/lib/nrfx
 	@cp -rp lib/picolibc/newlib/libc/ctype       build/release/tinygo/lib/picolibc/newlib/libc
 	@cp -rp lib/picolibc/newlib/libc/include     build/release/tinygo/lib/picolibc/newlib/libc
 	@cp -rp lib/picolibc/newlib/libc/locale      build/release/tinygo/lib/picolibc/newlib/libc
 	@cp -rp lib/picolibc/newlib/libc/string      build/release/tinygo/lib/picolibc/newlib/libc
 	@cp -rp lib/picolibc/newlib/libc/tinystdio   build/release/tinygo/lib/picolibc/newlib/libc
-	@cp -rp lib/picolibc-include         build/release/tinygo/lib
+	@cp -rp lib/picolibc/newlib/libm/common      build/release/tinygo/lib/picolibc/newlib/libm
+	@cp -rp lib/picolibc-stdio.c         build/release/tinygo/lib
 	@cp -rp lib/wasi-libc/sysroot        build/release/tinygo/lib/wasi-libc/sysroot
 	@cp -rp src                          build/release/tinygo/src
 	@cp -rp targets                      build/release/tinygo/targets
-	./build/tinygo build-library -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/compiler-rt.a compiler-rt
-	./build/tinygo build-library -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/compiler-rt.a compiler-rt
-	./build/tinygo build-library -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/compiler-rt.a compiler-rt
-	./build/tinygo build-library -target=armv6m-none-eabi  -o build/release/tinygo/pkg/armv6m-none-eabi/picolibc.a picolibc
-	./build/tinygo build-library -target=armv7m-none-eabi  -o build/release/tinygo/pkg/armv7m-none-eabi/picolibc.a picolibc
-	./build/tinygo build-library -target=armv7em-none-eabi -o build/release/tinygo/pkg/armv7em-none-eabi/picolibc.a picolibc
+	./build/tinygo build-library -target=armv6m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv6m-unknown-unknown-eabi/compiler-rt compiler-rt
+	./build/tinygo build-library -target=armv7m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv7m-unknown-unknown-eabi/compiler-rt compiler-rt
+	./build/tinygo build-library -target=armv7em-unknown-unknown-eabi -o build/release/tinygo/pkg/armv7em-unknown-unknown-eabi/compiler-rt compiler-rt
+	./build/tinygo build-library -target=armv6m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv6m-unknown-unknown-eabi/picolibc picolibc
+	./build/tinygo build-library -target=armv7m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv7m-unknown-unknown-eabi/picolibc picolibc
+	./build/tinygo build-library -target=armv7em-unknown-unknown-eabi -o build/release/tinygo/pkg/armv7em-unknown-unknown-eabi/picolibc picolibc
 
 release: build/release
 	tar -czf build/release.tar.gz -C build/release tinygo

README.md

@@ -43,50 +43,77 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for
 
 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.
 
-The following 44 microcontroller boards are currently supported:
+The following 71 microcontroller boards are currently supported:
 
 * [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333)
 * [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)
-* [Adafruit CLUE Alpha](https://www.adafruit.com/product/4500)
+* [Adafruit CLUE](https://www.adafruit.com/product/4500)
 * [Adafruit Feather M0](https://www.adafruit.com/product/2772)
 * [Adafruit Feather M4](https://www.adafruit.com/product/3857)
+* [Adafruit Feather M4 CAN](https://www.adafruit.com/product/4759)
 * [Adafruit Feather nRF52840 Express](https://www.adafruit.com/product/4062)
+* [Adafruit Feather nRF52840 Sense](https://www.adafruit.com/product/4516)
+* [Adafruit Feather RP2040](https://www.adafruit.com/product/4884)
 * [Adafruit Feather STM32F405 Express](https://www.adafruit.com/product/4382)
+* [Adafruit Grand Central M4](https://www.adafruit.com/product/4064)
 * [Adafruit ItsyBitsy M0](https://www.adafruit.com/product/3727)
 * [Adafruit ItsyBitsy M4](https://www.adafruit.com/product/3800)
 * [Adafruit ItsyBitsy nRF52840](https://www.adafruit.com/product/4481)
+* [Adafruit Matrix Portal M4](https://www.adafruit.com/product/4745)
 * [Adafruit Metro M4 Express Airlift](https://www.adafruit.com/product/4000)
 * [Adafruit PyBadge](https://www.adafruit.com/product/4200)
 * [Adafruit PyGamer](https://www.adafruit.com/product/4242)
 * [Adafruit PyPortal](https://www.adafruit.com/product/4116)
+* [Adafruit QT Py](https://www.adafruit.com/product/4600)
 * [Adafruit Trinket M0](https://www.adafruit.com/product/3500)
+* [Arduino Mega 1280](https://www.arduino.cc/en/Main/arduinoBoardMega/)
 * [Arduino Mega 2560](https://store.arduino.cc/arduino-mega-2560-rev3)
+* [Arduino MKR1000](https://store.arduino.cc/arduino-mkr1000-wifi)
+* [Arduino MKR WiFi 1010](https://store.arduino.cc/usa/mkr-wifi-1010)
 * [Arduino Nano](https://store.arduino.cc/arduino-nano)
-* [Arduino Nano33 IoT](https://store.arduino.cc/nano-33-iot)
+* [Arduino Nano 33 BLE](https://store.arduino.cc/nano-33-ble)
+* [Arduino Nano 33 BLE Sense](https://store.arduino.cc/nano-33-ble-sense)
+* [Arduino Nano 33 IoT](https://store.arduino.cc/nano-33-iot)
+* [Arduino Nano RP2040 Connect](https://store.arduino.cc/nano-rp2040-connect)
 * [Arduino Uno](https://store.arduino.cc/arduino-uno-rev3)
 * [Arduino Zero](https://store.arduino.cc/usa/arduino-zero)
 * [BBC micro:bit](https://microbit.org/)
+* [BBC micro:bit v2](https://microbit.org/new-microbit/)
 * [Digispark](http://digistump.com/products/1)
+* [Dragino LoRaWAN GPS Tracker LGT-92](http://www.dragino.com/products/lora-lorawan-end-node/item/142-lgt-92.html)
 * [ESP32](https://www.espressif.com/en/products/socs/esp32)
 * [ESP8266](https://www.espressif.com/en/products/socs/esp8266)
 * [Game Boy Advance](https://en.wikipedia.org/wiki/Game_Boy_Advance)
+* [M5Stack Core2](https://shop.m5stack.com/products/m5stack-core2-esp32-iot-development-kit)
 * [Makerdiary nRF52840-MDK](https://wiki.makerdiary.com/nrf52840-mdk/)
+* [Makerdiary nRF52840-MDK USB Dongle](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/)
+* [Microchip SAM E54 Xplained Pro](https://www.microchip.com/developmenttools/productdetails/atsame54-xpro)
+* [nice!nano](https://docs.nicekeyboards.com/#/nice!nano/)
 * [Nintendo Switch](https://www.nintendo.com/switch/)
 * [Nordic Semiconductor PCA10031](https://www.nordicsemi.com/eng/Products/nRF51-Dongle)
 * [Nordic Semiconductor PCA10040](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52-DK)
 * [Nordic Semiconductor PCA10056](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK)
+* [Nordic Semiconductor pca10059](https://www.nordicsemi.com/Software-and-tools/Development-Kits/nRF52840-Dongle)
 * [Particle Argon](https://docs.particle.io/datasheets/wi-fi/argon-datasheet/)
 * [Particle Boron](https://docs.particle.io/datasheets/cellular/boron-datasheet/)
 * [Particle Xenon](https://docs.particle.io/datasheets/discontinued/xenon-datasheet/)
 * [Phytec reel board](https://www.phytec.eu/product-eu/internet-of-things/reelboard/)
 * [PineTime DevKit](https://www.pine64.org/pinetime/)
 * [PJRC Teensy 3.6](https://www.pjrc.com/store/teensy36.html)
+* [PJRC Teensy 4.0](https://www.pjrc.com/store/teensy40.html)
+* [ProductivityOpen P1AM-100](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html)
+* [Raspberry Pi Pico](https://www.raspberrypi.org/products/raspberry-pi-pico/)
+* [Raytac MDBT50Q-RX Dongle (with TinyUF2 bootloader)](https://www.adafruit.com/product/5199)
 * [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html)
 * [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
 * [Seeed Sipeed MAix BiT](https://www.seeedstudio.com/Sipeed-MAix-BiT-for-RISC-V-AI-IoT-p-2872.html)
 * [SiFIve HiFive1](https://www.sifive.com/boards/hifive1)
-* [ST Micro "Nucleo F103RB"](https://www.st.com/en/evaluation-tools/nucleo-f103rb.html)
-* [ST Micro STM32F103XX "Bluepill"](http://wiki.stm32duino.com/index.php?title=Blue_Pill)
+* [ST Micro "Nucleo" F103RB](https://www.st.com/en/evaluation-tools/nucleo-f103rb.html)
+* [ST Micro "Nucleo" F722ZE](https://www.st.com/en/evaluation-tools/nucleo-f722ze.html)
+* [ST Micro "Nucleo" L031K6](https://www.st.com/ja/evaluation-tools/nucleo-l031k6.html)
+* [ST Micro "Nucleo" L432KC](https://www.st.com/ja/evaluation-tools/nucleo-l432kc.html)
+* [ST Micro "Nucleo" L552ZE](https://www.st.com/en/evaluation-tools/nucleo-l552ze-q.html)
+* [ST Micro STM32F103XX "Bluepill"](https://stm32-base.org/boards/STM32F103C8T6-Blue-Pill)
 * [ST Micro STM32F407 "Discovery"](https://www.st.com/en/evaluation-tools/stm32f4discovery.html)
 * [X9 Pro smartwatch](https://github.com/curtpw/nRF5x-device-reverse-engineering/tree/master/X9-nrf52832-activity-tracker/)
 

azure-pipelines.yml

@@ -1,92 +0,0 @@
-# Avoid lengthy LLVM rebuilds on each newly pushed branch. Pull requests will
-# be built anyway.
-trigger:
-- release
-- dev
-
-jobs:
-- job: Build
-  timeoutInMinutes: 240 # 4h
-  pool:
-    vmImage: 'VS2017-Win2016'
-  steps:
-    - task: GoTool@0
-      inputs:
-        version: '1.15'
-    - checkout: self
-      fetchDepth: 1
-    - task: Cache@2
-      displayName: Cache LLVM source
-      inputs:
-        key: llvm-source-11-windows-v1
-        path: llvm-project
-    - task: Bash@3
-      displayName: Download LLVM source
-      inputs:
-        targetType: inline
-        script: |
-          make llvm-source
-          # Workaround for bad symlinks:
-          # https://github.com/microsoft/azure-pipelines-tasks/issues/13418
-          rm -f llvm-project/libcxx/test/std/input.output/filesystems/Inputs/static_test_env/bad_symlink
-    - task: CacheBeta@0
-      displayName: Cache LLVM build
-      inputs:
-        key: llvm-build-11-windows-v3
-        path: llvm-build
-    - task: Bash@3
-      displayName: Build LLVM
-      inputs:
-        targetType: inline
-        script: |
-          if [ ! -f llvm-build/lib/liblldELF.a ]
-          then
-            # install dependencies
-            choco install ninja
-            # hack ninja to use fewer jobs
-            echo -e 'C:\\ProgramData\\Chocolatey\\bin\\ninja -j4 %*' > /usr/bin/ninja.bat
-            # build!
-            make llvm-build
-          fi
-    - task: Bash@3
-      displayName: Install QEMU
-      inputs:
-        targetType: inline
-        script: choco install qemu --version=2020.06.12
-    - task: CacheBeta@0
-      displayName: Cache wasi-libc sysroot
-      inputs:
-        key: wasi-libc-sysroot-v3
-        path: lib/wasi-libc/sysroot
-    - task: Bash@3
-      displayName: Build wasi-libc
-      inputs:
-        targetType: inline
-        script: PATH=/usr/bin:$PATH make wasi-libc
-    - task: Bash@3
-      displayName: Test TinyGo
-      inputs:
-        targetType: inline
-        script: |
-          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
-          unset GOROOT
-          make test
-    - task: Bash@3
-      displayName: Build TinyGo release tarball
-      inputs:
-        targetType: inline
-        script: |
-          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
-          unset GOROOT
-          make build/release -j4
-    - publish: $(System.DefaultWorkingDirectory)/build/release/tinygo
-      displayName: Publish zip as artifact
-      artifact: tinygo
-    - task: Bash@3
-      displayName: Smoke tests
-      inputs:
-        targetType: inline
-        script: |
-          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
-          unset GOROOT
-          make smoketest TINYGO=build/tinygo AVR=0 XTENSA=0

builder/ar.go

@@ -5,6 +5,7 @@ import (
 	"debug/elf"
 	"encoding/binary"
 	"errors"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -17,17 +18,12 @@ import (
 // given as a parameter. It is equivalent to the following command:
 //
 //     ar -rcs <archivePath> <objs...>
-func makeArchive(archivePath string, objs []string) error {
+func makeArchive(arfile *os.File, objs []string) error {
 	// Open the archive file.
-	arfile, err := os.Create(archivePath)
-	if err != nil {
-		return err
-	}
-	defer arfile.Close()
 	arwriter := ar.NewWriter(arfile)
-	err = arwriter.WriteGlobalHeader()
+	err := arwriter.WriteGlobalHeader()
 	if err != nil {
-		return &os.PathError{"write ar header", archivePath, err}
+		return &os.PathError{Op: "write ar header", Path: arfile.Name(), Err: err}
 	}
 
 	// Open all object files and read the symbols for the symbol table.
@@ -35,21 +31,17 @@ func makeArchive(archivePath string, objs []string) error {
 		name      string // symbol name
 		fileIndex int    // index into objfiles
 	}{}
-	objfiles := make([]struct {
-		file          *os.File
-		archiveOffset int32
-	}, len(objs))
+	archiveOffsets := make([]int32, len(objs))
 	for i, objpath := range objs {
 		objfile, err := os.Open(objpath)
 		if err != nil {
 			return err
 		}
-		objfiles[i].file = objfile
 
 		// Read the symbols and add them to the symbol table.
 		dbg, err := elf.NewFile(objfile)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to open file %s: %w", objpath, err)
 		}
 		symbols, err := dbg.Symbols()
 		if err != nil {
@@ -61,9 +53,8 @@ func makeArchive(archivePath string, objs []string) error {
 				// Don't include local symbols (STB_LOCAL).
 				continue
 			}
-			if elf.ST_TYPE(symbol.Info) != elf.STT_FUNC {
+			if elf.ST_TYPE(symbol.Info) != elf.STT_FUNC && elf.ST_TYPE(symbol.Info) != elf.STT_OBJECT {
 				// Not a function.
-				// TODO: perhaps globals variables should also be included?
 				continue
 			}
 			// Include in archive.
@@ -72,6 +63,10 @@ func makeArchive(archivePath string, objs []string) error {
 				fileIndex int
 			}{symbol.Name, i})
 		}
+
+		// Close file, to avoid issues with too many open files (especially on
+		// MacOS X).
+		objfile.Close()
 	}
 
 	// Create the symbol table buffer.
@@ -125,7 +120,12 @@ func makeArchive(archivePath string, objs []string) error {
 	}
 
 	// Add all object files to the archive.
-	for i, objfile := range objfiles {
+	for i, objpath := range objs {
+		objfile, err := os.Open(objpath)
+		if err != nil {
+			return err
+		}
+
 		// Store the start index, for when we'll update the symbol table with
 		// the correct file start indices.
 		offset, err := arfile.Seek(0, os.SEEK_CUR)
@@ -133,17 +133,17 @@ func makeArchive(archivePath string, objs []string) error {
 			return err
 		}
 		if int64(int32(offset)) != offset {
-			return errors.New("large archives (4GB+) not supported: " + archivePath)
+			return errors.New("large archives (4GB+) not supported: " + arfile.Name())
 		}
-		objfiles[i].archiveOffset = int32(offset)
+		archiveOffsets[i] = int32(offset)
 
 		// Write the file header.
-		st, err := objfile.file.Stat()
+		st, err := objfile.Stat()
 		if err != nil {
 			return err
 		}
 		err = arwriter.WriteHeader(&ar.Header{
-			Name:    filepath.Base(objfile.file.Name()),
+			Name:    filepath.Base(objfile.Name()),
 			ModTime: time.Unix(0, 0),
 			Uid:     0,
 			Gid:     0,
@@ -155,22 +155,22 @@ func makeArchive(archivePath string, objs []string) error {
 		}
 
 		// Copy the file contents into the archive.
-		n, err := io.Copy(arwriter, objfile.file)
+		n, err := io.Copy(arwriter, objfile)
 		if err != nil {
 			return err
 		}
 		if n != st.Size() {
-			return errors.New("file modified during ar creation: " + archivePath)
+			return errors.New("file modified during ar creation: " + arfile.Name())
 		}
 
 		// File is not needed anymore.
-		objfile.file.Close()
+		objfile.Close()
 	}
 
 	// Create symbol indices.
 	indicesBuf := &bytes.Buffer{}
 	for _, sym := range symbolTable {
-		err = binary.Write(indicesBuf, binary.BigEndian, objfiles[sym.fileIndex].archiveOffset)
+		err = binary.Write(indicesBuf, binary.BigEndian, archiveOffsets[sym.fileIndex])
 		if err != nil {
 			return err
 		}

builder/buildcache.go

@@ -1,118 +0,0 @@
-package builder
-
-import (
-	"io"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-// Return the newest timestamp of all the file paths passed in. Used to check
-// for stale caches.
-func cacheTimestamp(paths []string) (time.Time, error) {
-	var timestamp time.Time
-	for _, path := range paths {
-		st, err := os.Stat(path)
-		if err != nil {
-			return time.Time{}, err
-		}
-		if timestamp.IsZero() {
-			timestamp = st.ModTime()
-		} else if timestamp.Before(st.ModTime()) {
-			timestamp = st.ModTime()
-		}
-	}
-	return timestamp, nil
-}
-
-// Try to load a given file from the cache. Return "", nil if no cached file can
-// be found (or the file is stale), return the absolute path if there is a cache
-// and return an error on I/O errors.
-//
-// TODO: the configKey is currently ignored. It is supposed to be used as extra
-// data for the cache key, like the compiler version and arguments.
-func cacheLoad(name, configKey string, sourceFiles []string) (string, error) {
-	cachepath := filepath.Join(goenv.Get("GOCACHE"), name)
-	cacheStat, err := os.Stat(cachepath)
-	if os.IsNotExist(err) {
-		return "", nil // does not exist
-	} else if err != nil {
-		return "", err // cannot stat cache file
-	}
-
-	sourceTimestamp, err := cacheTimestamp(sourceFiles)
-	if err != nil {
-		return "", err // cannot stat source files
-	}
-
-	if cacheStat.ModTime().After(sourceTimestamp) {
-		return cachepath, nil
-	} else {
-		os.Remove(cachepath)
-		// stale cache
-		return "", nil
-	}
-}
-
-// Store the file located at tmppath in the cache with the given name. The
-// tmppath may or may not be gone afterwards.
-//
-// Note: the configKey is ignored, see cacheLoad.
-func cacheStore(tmppath, name, configKey string, sourceFiles []string) (string, error) {
-	// get the last modified time
-	if len(sourceFiles) == 0 {
-		panic("cache: no source files")
-	}
-
-	// TODO: check the config key
-
-	dir := goenv.Get("GOCACHE")
-	err := os.MkdirAll(dir, 0777)
-	if err != nil {
-		return "", err
-	}
-	cachepath := filepath.Join(dir, name)
-	err = moveFile(tmppath, cachepath)
-	if err != nil {
-		return "", err
-	}
-	return cachepath, nil
-}
-
-// moveFile renames the file from src to dst. If renaming doesn't work (for
-// example, the rename crosses a filesystem boundary), the file is copied and
-// the old file is removed.
-func moveFile(src, dst string) error {
-	err := os.Rename(src, dst)
-	if err == nil {
-		// Success!
-		return nil
-	}
-	// Failed to move, probably a different filesystem.
-	// Do a copy + remove.
-	inf, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer inf.Close()
-	outpath := dst + ".tmp"
-	outf, err := os.Create(outpath)
-	if err != nil {
-		return err
-	}
-
-	_, err = io.Copy(outf, inf)
-	if err != nil {
-		os.Remove(outpath)
-		return err
-	}
-
-	err = outf.Close()
-	if err != nil {
-		return err
-	}
-
-	return os.Rename(dst+".tmp", dst)
-}

builder/builder_test.go

@@ -0,0 +1,146 @@
+package builder
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+	"github.com/tinygo-org/tinygo/goenv"
+	"tinygo.org/x/go-llvm"
+)
+
+// Test whether the Clang generated "target-cpu" attribute matches the CPU
+// property in TinyGo target files.
+func TestClangAttributes(t *testing.T) {
+	var targetNames = []string{
+		// Please keep this list sorted!
+		"atmega328p",
+		"atmega1280",
+		"atmega1284p",
+		"atmega2560",
+		"attiny85",
+		"cortex-m0",
+		"cortex-m0plus",
+		"cortex-m3",
+		//"cortex-m33", // TODO: broken in LLVM 11, fixed in https://reviews.llvm.org/D90305
+		"cortex-m4",
+		"cortex-m7",
+		"esp32c3",
+		"fe310",
+		"gameboy-advance",
+		"k210",
+		"nintendoswitch",
+		"riscv-qemu",
+		"wasi",
+		"wasm",
+	}
+	if hasBuiltinTools {
+		// hasBuiltinTools is set when TinyGo is statically linked with LLVM,
+		// which also implies it was built with Xtensa support.
+		targetNames = append(targetNames, "esp32", "esp8266")
+	}
+	for _, targetName := range targetNames {
+		targetName := targetName
+		t.Run(targetName, func(t *testing.T) {
+			testClangAttributes(t, &compileopts.Options{Target: targetName})
+		})
+	}
+
+	for _, options := range []*compileopts.Options{
+		{GOOS: "linux", GOARCH: "386"},
+		{GOOS: "linux", GOARCH: "amd64"},
+		{GOOS: "linux", GOARCH: "arm"},
+		{GOOS: "linux", GOARCH: "arm64"},
+		{GOOS: "darwin", GOARCH: "amd64"},
+		{GOOS: "darwin", GOARCH: "arm64"},
+	} {
+		t.Run("GOOS="+options.GOOS+",GOARCH="+options.GOARCH, func(t *testing.T) {
+			testClangAttributes(t, options)
+		})
+	}
+}
+
+func testClangAttributes(t *testing.T, options *compileopts.Options) {
+	testDir := t.TempDir()
+	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
+
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+
+	target, err := compileopts.LoadTarget(options)
+	if err != nil {
+		t.Fatalf("could not load target: %s", err)
+	}
+	config := compileopts.Config{
+		Options:      options,
+		Target:       target,
+		ClangHeaders: clangHeaderPath,
+	}
+
+	// Create a very simple C input file.
+	srcpath := filepath.Join(testDir, "test.c")
+	err = ioutil.WriteFile(srcpath, []byte("int add(int a, int b) { return a + b; }"), 0o666)
+	if err != nil {
+		t.Fatalf("could not write target file %s: %s", srcpath, err)
+	}
+
+	// Compile this file using Clang.
+	outpath := filepath.Join(testDir, "test.bc")
+	flags := append([]string{"-c", "-emit-llvm", "-o", outpath, srcpath}, config.CFlags()...)
+	if config.GOOS() == "darwin" {
+		// Silence some warnings that happen when testing GOOS=darwin on
+		// something other than MacOS.
+		flags = append(flags, "-Wno-missing-sysroot", "-Wno-incompatible-sysroot")
+	}
+	err = runCCompiler(flags...)
+	if err != nil {
+		t.Fatalf("failed to compile %s: %s", srcpath, err)
+	}
+
+	// Read the resulting LLVM bitcode.
+	mod, err := ctx.ParseBitcodeFile(outpath)
+	if err != nil {
+		t.Fatalf("could not parse bitcode file %s: %s", outpath, err)
+	}
+	defer mod.Dispose()
+
+	// Check whether the LLVM target matches.
+	if mod.Target() != config.Triple() {
+		t.Errorf("target has LLVM triple %#v but Clang makes it LLVM triple %#v", config.Triple(), mod.Target())
+	}
+
+	// Check the "target-cpu"  string attribute of the add function.
+	add := mod.NamedFunction("add")
+	var cpu string
+	cpuAttr := add.GetStringAttributeAtIndex(-1, "target-cpu")
+	if !cpuAttr.IsNil() {
+		cpu = cpuAttr.GetStringValue()
+	}
+	if cpu != config.CPU() {
+		t.Errorf("target has CPU %#v but Clang makes it CPU %#v", config.CPU(), cpu)
+	}
+}
+
+// This TestMain is necessary because TinyGo may also be invoked to run certain
+// LLVM tools in a separate process. Not capturing these invocations would lead
+// to recursive tests.
+func TestMain(m *testing.M) {
+	if len(os.Args) >= 2 {
+		switch os.Args[1] {
+		case "clang", "ld.lld", "wasm-ld":
+			// Invoke a specific tool.
+			err := RunTool(os.Args[1], os.Args[2:]...)
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				os.Exit(1)
+			}
+			os.Exit(0)
+		}
+	}
+
+	// Run normal tests.
+	os.Exit(m.Run())
+}

builder/builtins.go

@@ -157,10 +157,12 @@ var aeabiBuiltins = []string{
 //
 // For more information, see: https://compiler-rt.llvm.org/
 var CompilerRT = Library{
-	name:      "compiler-rt",
-	cflags:    func() []string { return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"} },
+	name: "compiler-rt",
+	cflags: func(target, headerPath string) []string {
+		return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"}
+	},
 	sourceDir: "lib/compiler-rt/lib/builtins",
-	sources: func(target string) []string {
+	librarySources: func(target string) []string {
 		builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
 		if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
 			builtins = append(builtins, aeabiBuiltins...)

builder/cc.go

@@ -0,0 +1,313 @@
+package builder
+
+// This file implements a wrapper around the C compiler (Clang) which uses a
+// build cache.
+
+import (
+	"crypto/sha512"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"unicode"
+
+	"github.com/tinygo-org/tinygo/goenv"
+	"tinygo.org/x/go-llvm"
+)
+
+// compileAndCacheCFile compiles a C or assembly file using a build cache.
+// Compiling the same file again (if nothing changed, including included header
+// files) the output is loaded from the build cache instead.
+//
+// Its operation is a bit complex (more complex than Go package build caching)
+// because the list of file dependencies is only known after the file is
+// compiled. However, luckily compilers have a flag to write a list of file
+// dependencies in Makefile syntax which can be used for caching.
+//
+// Because of this complexity, every file has in fact two cached build outputs:
+// the file itself, and the list of dependencies. Its operation is as follows:
+//
+//   depfile = hash(path, compiler, cflags, ...)
+//   if depfile exists:
+//     outfile = hash of all files and depfile name
+//     if outfile exists:
+//       # cache hit
+//       return outfile
+//   # cache miss
+//   tmpfile = compile file
+//   read dependencies (side effect of compile)
+//   write depfile
+//   outfile = hash of all files and depfile name
+//   rename tmpfile to outfile
+//
+// There are a few edge cases that are not handled:
+// - If a file is added to an include path, that file may be included instead of
+//   some other file. This would be fixed by also including lookup failures in the
+//   dependencies file, but I'm not aware of a compiler which does that.
+// - The Makefile syntax that compilers output has issues, see readDepFile for
+//   details.
+// - A header file may be changed to add/remove an include. This invalidates the
+//   depfile but without invalidating its name. For this reason, the depfile is
+//   written on each new compilation (even when it seems unnecessary). However, it
+//   could in rare cases lead to a stale file fetched from the cache.
+func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands func(string, ...string)) (string, error) {
+	// Hash input file.
+	fileHash, err := hashFile(abspath)
+	if err != nil {
+		return "", err
+	}
+
+	// Create cache key for the dependencies file.
+	buf, err := json.Marshal(struct {
+		Path        string
+		Hash        string
+		Flags       []string
+		LLVMVersion string
+	}{
+		Path:        abspath,
+		Hash:        fileHash,
+		Flags:       cflags,
+		LLVMVersion: llvm.Version,
+	})
+	if err != nil {
+		panic(err) // shouldn't happen
+	}
+	depfileNameHashBuf := sha512.Sum512_224(buf)
+	depfileNameHash := hex.EncodeToString(depfileNameHashBuf[:])
+
+	// Load dependencies file, if possible.
+	depfileName := "dep-" + depfileNameHash + ".json"
+	depfileCachePath := filepath.Join(goenv.Get("GOCACHE"), depfileName)
+	depfileBuf, err := ioutil.ReadFile(depfileCachePath)
+	var dependencies []string // sorted list of dependency paths
+	if err == nil {
+		// There is a dependency file, that's great!
+		// Parse it first.
+		err := json.Unmarshal(depfileBuf, &dependencies)
+		if err != nil {
+			return "", fmt.Errorf("could not parse dependencies JSON: %w", err)
+		}
+
+		// Obtain hashes of all the files listed as a dependency.
+		outpath, err := makeCFileCachePath(dependencies, depfileNameHash)
+		if err == nil {
+			if _, err := os.Stat(outpath); err == nil {
+				return outpath, nil
+			} else if !os.IsNotExist(err) {
+				return "", err
+			}
+		}
+	} else if !os.IsNotExist(err) {
+		// expected either nil or IsNotExist
+		return "", err
+	}
+
+	objTmpFile, err := ioutil.TempFile(goenv.Get("GOCACHE"), "tmp-*.o")
+	if err != nil {
+		return "", err
+	}
+	objTmpFile.Close()
+	depTmpFile, err := ioutil.TempFile(tmpdir, "dep-*.d")
+	if err != nil {
+		return "", err
+	}
+	depTmpFile.Close()
+	flags := append([]string{}, cflags...)                                   // copy cflags
+	flags = append(flags, "-MD", "-MV", "-MTdeps", "-MF", depTmpFile.Name()) // autogenerate dependencies
+	flags = append(flags, "-c", "-o", objTmpFile.Name(), abspath)
+	if strings.ToLower(filepath.Ext(abspath)) == ".s" {
+		// If this is an assembly file (.s or .S, lowercase or uppercase), then
+		// we'll need to add -Qunused-arguments because many parameters are
+		// relevant to C, not assembly. And with -Werror, having meaningless
+		// flags (for the assembler) is a compiler error.
+		flags = append(flags, "-Qunused-arguments")
+	}
+	if printCommands != nil {
+		printCommands("clang", flags...)
+	}
+	err = runCCompiler(flags...)
+	if err != nil {
+		return "", &commandError{"failed to build", abspath, err}
+	}
+
+	// Create sorted and uniqued slice of dependencies.
+	dependencyPaths, err := readDepFile(depTmpFile.Name())
+	if err != nil {
+		return "", err
+	}
+	dependencyPaths = append(dependencyPaths, abspath) // necessary for .s files
+	dependencySet := make(map[string]struct{}, len(dependencyPaths))
+	var dependencySlice []string
+	for _, path := range dependencyPaths {
+		if _, ok := dependencySet[path]; ok {
+			continue
+		}
+		dependencySet[path] = struct{}{}
+		dependencySlice = append(dependencySlice, path)
+	}
+	sort.Strings(dependencySlice)
+
+	// Write dependencies file.
+	f, err := ioutil.TempFile(filepath.Dir(depfileCachePath), depfileName)
+	if err != nil {
+		return "", err
+	}
+
+	buf, err = json.MarshalIndent(dependencySlice, "", "\t")
+	if err != nil {
+		panic(err) // shouldn't happen
+	}
+	_, err = f.Write(buf)
+	if err != nil {
+		return "", err
+	}
+	err = f.Close()
+	if err != nil {
+		return "", err
+	}
+	err = os.Rename(f.Name(), depfileCachePath)
+	if err != nil {
+		return "", err
+	}
+
+	// Move temporary object file to final location.
+	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash)
+	if err != nil {
+		return "", err
+	}
+	err = os.Rename(objTmpFile.Name(), outpath)
+	if err != nil {
+		return "", err
+	}
+
+	return outpath, nil
+}
+
+// Create a cache path (a path in GOCACHE) to store the output of a compiler
+// job. This path is based on the dep file name (which is a hash of metadata
+// including compiler flags) and the hash of all input files in the paths slice.
+func makeCFileCachePath(paths []string, depfileNameHash string) (string, error) {
+	// Hash all input files.
+	fileHashes := make(map[string]string, len(paths))
+	for _, path := range paths {
+		hash, err := hashFile(path)
+		if err != nil {
+			return "", err
+		}
+		fileHashes[path] = hash
+	}
+
+	// Calculate a cache key based on the above hashes.
+	buf, err := json.Marshal(struct {
+		DepfileHash string
+		FileHashes  map[string]string
+	}{
+		DepfileHash: depfileNameHash,
+		FileHashes:  fileHashes,
+	})
+	if err != nil {
+		panic(err) // shouldn't happen
+	}
+	outFileNameBuf := sha512.Sum512_224(buf)
+	cacheKey := hex.EncodeToString(outFileNameBuf[:])
+
+	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+".o")
+	return outpath, nil
+}
+
+// hashFile hashes the given file path and returns the hash as a hex string.
+func hashFile(path string) (string, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return "", fmt.Errorf("failed to hash file: %w", err)
+	}
+	defer f.Close()
+	fileHasher := sha512.New512_224()
+	_, err = io.Copy(fileHasher, f)
+	if err != nil {
+		return "", fmt.Errorf("failed to hash file: %w", err)
+	}
+	return hex.EncodeToString(fileHasher.Sum(nil)), nil
+}
+
+// readDepFile reads a dependency file in NMake (Visual Studio make) format. The
+// file is assumed to have a single target named deps.
+//
+// There are roughly three make syntax variants:
+// - BSD make, which doesn't support any escaping. This means that many special
+//   characters are not supported in file names.
+// - GNU make, which supports escaping using a backslash but when it fails to
+//   find a file it tries to fall back with the literal path name (to match BSD
+//   make).
+// - NMake (Visual Studio) and Jom, which simply quote the string if there are
+//   any weird characters.
+// Clang supports two variants: a format that's a compromise between BSD and GNU
+// make (and is buggy to match GCC which is equally buggy), and NMake/Jom, which
+// is at least somewhat sane. This last format isn't perfect either: it does not
+// correctly handle filenames with quote marks in them. Those are generally not
+// allowed on Windows, but of course can be used on POSIX like systems. Still,
+// it's the most sane of any of the formats so readDepFile will use that format.
+func readDepFile(filename string) ([]string, error) {
+	buf, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	if len(buf) == 0 {
+		return nil, nil
+	}
+	return parseDepFile(string(buf))
+}
+
+func parseDepFile(s string) ([]string, error) {
+	// This function makes no attempt at parsing anything other than Clang -MD
+	// -MV output.
+
+	// For Windows: replace CRLF with LF to make the logic below simpler.
+	s = strings.ReplaceAll(s, "\r\n", "\n")
+
+	// Collapse all lines ending in a backslash. These backslashes are really
+	// just a way to continue a line without making very long lines.
+	s = strings.ReplaceAll(s, "\\\n", " ")
+
+	// Only use the first line, which is expected to begin with "deps:".
+	line := strings.SplitN(s, "\n", 2)[0]
+	if !strings.HasPrefix(line, "deps:") {
+		return nil, errors.New("readDepFile: expected 'deps:' prefix")
+	}
+	line = strings.TrimSpace(line[len("deps:"):])
+
+	var deps []string
+	for line != "" {
+		if line[0] == '"' {
+			// File path is quoted. Path ends with double quote.
+			// This does not handle double quotes in path names, which is a
+			// problem on non-Windows systems.
+			line = line[1:]
+			end := strings.IndexByte(line, '"')
+			if end < 0 {
+				return nil, errors.New("readDepFile: path is incorrectly quoted")
+			}
+			dep := line[:end]
+			line = strings.TrimSpace(line[end+1:])
+			deps = append(deps, dep)
+		} else {
+			// File path is not quoted. Path ends in space or EOL.
+			end := strings.IndexFunc(line, unicode.IsSpace)
+			if end < 0 {
+				// last dependency
+				deps = append(deps, line)
+				break
+			}
+			dep := line[:end]
+			line = strings.TrimSpace(line[end:])
+			deps = append(deps, dep)
+		}
+	}
+	return deps, nil
+}

builder/cc_test.go

@@ -0,0 +1,33 @@
+package builder
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSplitDepFile(t *testing.T) {
+	for i, tc := range []struct {
+		in  string
+		out []string
+	}{
+		{`deps: foo bar`, []string{"foo", "bar"}},
+		{`deps: foo "bar"`, []string{"foo", "bar"}},
+		{`deps: "foo" bar`, []string{"foo", "bar"}},
+		{`deps: "foo bar"`, []string{"foo bar"}},
+		{`deps: "foo bar" `, []string{"foo bar"}},
+		{"deps: foo\nbar", []string{"foo"}},
+		{"deps: foo \\\nbar", []string{"foo", "bar"}},
+		{"deps: foo\\bar \\\nbaz", []string{"foo\\bar", "baz"}},
+		{"deps: foo\\bar \\\r\n baz", []string{"foo\\bar", "baz"}}, // Windows uses CRLF line endings
+	} {
+		out, err := parseDepFile(tc.in)
+		if err != nil {
+			t.Errorf("test #%d failed: %v", i, err)
+			continue
+		}
+		if !reflect.DeepEqual(out, tc.out) {
+			t.Errorf("test #%d failed: expected %#v but got %#v", i, tc.out, out)
+			continue
+		}
+	}
+}

builder/commands.go

@@ -21,6 +21,7 @@ func init() {
 	commands["clang"] = []string{"clang-" + llvmMajor}
 	commands["ld.lld"] = []string{"ld.lld-" + llvmMajor, "ld.lld"}
 	commands["wasm-ld"] = []string{"wasm-ld-" + llvmMajor, "wasm-ld"}
+	commands["lldb"] = []string{"lldb-" + llvmMajor, "lldb"}
 	// Add the path to a Homebrew-installed LLVM for ease of use (no need to
 	// manually set $PATH).
 	if runtime.GOOS == "darwin" {
@@ -28,6 +29,7 @@ func init() {
 		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
 		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
 		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
+		commands["lldb"] = append(commands["lldb"], prefix+"lldb")
 	}
 	// Add the path for when LLVM was installed with the installer from
 	// llvm.org, which by default doesn't add LLVM to the $PATH environment
@@ -36,6 +38,7 @@ func init() {
 		commands["clang"] = append(commands["clang"], "clang", "C:\\Program Files\\LLVM\\bin\\clang.exe")
 		commands["ld.lld"] = append(commands["ld.lld"], "lld", "C:\\Program Files\\LLVM\\bin\\lld.exe")
 		commands["wasm-ld"] = append(commands["wasm-ld"], "C:\\Program Files\\LLVM\\bin\\wasm-ld.exe")
+		commands["lldb"] = append(commands["lldb"], "C:\\Program Files\\LLVM\\bin\\lldb.exe")
 	}
 	// Add the path to LLVM installed from ports.
 	if runtime.GOOS == "freebsd" {
@@ -43,23 +46,34 @@ func init() {
 		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
 		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
 		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
+		commands["lldb"] = append(commands["lldb"], prefix+"lldb")
 	}
 }
 
-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()
+// LookupCommand looks up the executable name for a given LLVM tool such as
+// clang or wasm-ld. It returns the (relative) command that can be used to
+// invoke the tool or an error if it could not be found.
+func LookupCommand(name string) (string, error) {
+	for _, cmdName := range commands[name] {
+		_, err := exec.LookPath(cmdName)
 		if err != nil {
-			if err, ok := err.(*exec.Error); ok && (err.Err == exec.ErrNotFound || err.Err.Error() == "file does not exist") {
-				// this command was not found, try the next
+			if errors.Unwrap(err) == exec.ErrNotFound {
 				continue
 			}
-			return err
+			return cmdName, err
 		}
-		return nil
+		return cmdName, nil
 	}
-	return errors.New("none of these commands were found in your $PATH: " + strings.Join(cmdNames, " "))
+	return "", errors.New("%#v: none of these commands were found in your $PATH: " + strings.Join(commands[name], " "))
+}
+
+func execCommand(name string, args ...string) error {
+	name, err := LookupCommand(name)
+	if err != nil {
+		return err
+	}
+	cmd := exec.Command(name, args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
 }

builder/config.go

@@ -13,22 +13,32 @@ import (
 // uses the currently active GOPATH (from the goenv package) to determine the Go
 // version to use.
 func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
-	spec, err := compileopts.LoadTarget(options.Target)
+	spec, err := compileopts.LoadTarget(options)
 	if err != nil {
 		return nil, err
 	}
+
+	if options.OpenOCDCommands != nil {
+		// Override the OpenOCDCommands from the target spec if specified on
+		// the command-line
+		spec.OpenOCDCommands = options.OpenOCDCommands
+	}
+
 	goroot := goenv.Get("GOROOT")
 	if goroot == "" {
 		return nil, errors.New("cannot locate $GOROOT, please set it manually")
 	}
+
 	major, minor, err := goenv.GetGorootVersion(goroot)
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}
-	if major != 1 || minor < 11 || minor > 15 {
-		return nil, fmt.Errorf("requires go version 1.11 through 1.15, got go%d.%d", major, minor)
+	if major != 1 || minor < 15 || minor > 17 {
+		return nil, fmt.Errorf("requires go version 1.15 through 1.17, got go%d.%d", major, minor)
 	}
+
 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
+
 	return &compileopts.Config{
 		Options:        options,
 		Target:         spec,

builder/elfpatch.go

@@ -0,0 +1,57 @@
+package builder
+
+import (
+	"debug/elf"
+	"fmt"
+	"os"
+)
+
+func getElfSectionData(executable string, sectionName string) ([]byte, elf.FileHeader, error) {
+	elfFile, err := elf.Open(executable)
+	if err != nil {
+		return nil, elf.FileHeader{}, err
+	}
+	defer elfFile.Close()
+
+	section := elfFile.Section(sectionName)
+	if section == nil {
+		return nil, elf.FileHeader{}, fmt.Errorf("could not find %s section", sectionName)
+	}
+
+	data, err := section.Data()
+
+	return data, elfFile.FileHeader, err
+}
+
+func replaceElfSection(executable string, sectionName string, data []byte) error {
+	fp, err := os.OpenFile(executable, os.O_RDWR, 0)
+	if err != nil {
+		return err
+	}
+	defer fp.Close()
+
+	elfFile, err := elf.Open(executable)
+	if err != nil {
+		return err
+	}
+	defer elfFile.Close()
+
+	section := elfFile.Section(sectionName)
+	if section == nil {
+		return fmt.Errorf("could not find %s section", sectionName)
+	}
+
+	// Implicitly check for compressed sections
+	if section.Size != section.FileSize {
+		return fmt.Errorf("expected section %s to have identical size and file size, got %d and %d", sectionName, section.Size, section.FileSize)
+	}
+
+	// Only permit complete replacement of section
+	if section.Size != uint64(len(data)) {
+		return fmt.Errorf("expected section %s to have size %d, was actually %d", sectionName, len(data), section.Size)
+	}
+
+	// Write the replacement section data
+	_, err = fp.WriteAt(data, int64(section.Offset))
+	return err
+}

builder/esp.go

@@ -78,11 +78,21 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	// An added benefit is that we don't need to check for errors all the time.
 	outf := &bytes.Buffer{}
 
+	// Chip IDs. Source:
+	// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L22
+	chip_id := map[string]uint16{
+		"esp32":   0x0000,
+		"esp32c3": 0x0005,
+	}[format]
+
 	// Image header.
 	switch format {
-	case "esp32":
+	case "esp32", "esp32c3":
 		// Header format:
-		// https://github.com/espressif/esp-idf/blob/8fbb63c2/components/bootloader_support/include/esp_image_format.h#L58
+		// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L71
+		// Note: not adding a SHA256 hash as the binary is modified by
+		// esptool.py while flashing and therefore the hash won't be valid
+		// anymore.
 		binary.Write(outf, binary.LittleEndian, struct {
 			magic          uint8
 			segment_count  uint8
@@ -91,15 +101,18 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 			entry_addr     uint32
 			wp_pin         uint8
 			spi_pin_drv    [3]uint8
-			reserved       [11]uint8
+			chip_id        uint16
+			min_chip_rev   uint8
+			reserved       [8]uint8
 			hash_appended  bool
 		}{
 			magic:          0xE9,
 			segment_count:  byte(len(segments)),
-			spi_mode:       0, // irrelevant, replaced by esptool when flashing
-			spi_speed_size: 0, // spi_speed, spi_size: replaced by esptool when flashing
+			spi_mode:       2,    // ESP_IMAGE_SPI_MODE_DIO
+			spi_speed_size: 0x1f, // ESP_IMAGE_SPI_SPEED_80M, ESP_IMAGE_FLASH_SIZE_2MB
 			entry_addr:     uint32(inf.Entry),
 			wp_pin:         0xEE, // disable WP pin
+			chip_id:        chip_id,
 			hash_appended:  true, // add a SHA256 hash
 		})
 	case "esp8266":
@@ -142,7 +155,7 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	outf.Write(make([]byte, 15-outf.Len()%16))
 	outf.WriteByte(checksum)
 
-	if format == "esp32" {
+	if format != "esp8266" {
 		// SHA256 hash (to protect against image corruption, not for security).
 		hash := sha256.Sum256(outf.Bytes())
 		outf.Write(hash[:])

builder/jobs.go

@@ -0,0 +1,199 @@
+package builder
+
+// This file implements a job runner for the compiler, which runs jobs in
+// parallel while taking care of dependencies.
+
+import (
+	"fmt"
+	"runtime"
+	"time"
+)
+
+// Set to true to enable logging in the job runner. This may help to debug
+// concurrency or performance issues.
+const jobRunnerDebug = false
+
+type jobState uint8
+
+const (
+	jobStateQueued   jobState = iota // not yet running
+	jobStateRunning                  // running
+	jobStateFinished                 // finished running
+)
+
+// compileJob is a single compiler job, comparable to a single Makefile target.
+// It is used to orchestrate various compiler tasks that can be run in parallel
+// but that have dependencies and thus have limitations in how they can be run.
+type compileJob struct {
+	description  string // description, only used for logging
+	dependencies []*compileJob
+	result       string // result (path)
+	run          func(*compileJob) (err error)
+	state        jobState
+	err          error         // error if finished
+	duration     time.Duration // how long it took to run this job (only set after finishing)
+}
+
+// dummyCompileJob returns a new *compileJob that produces an output without
+// doing anything. This can be useful where a *compileJob producing an output is
+// expected but nothing needs to be done, for example for a load from a cache.
+func dummyCompileJob(result string) *compileJob {
+	return &compileJob{
+		description: "<dummy>",
+		result:      result,
+	}
+}
+
+// readyToRun returns whether this job is ready to run: it is itself not yet
+// started and all dependencies are finished.
+func (job *compileJob) readyToRun() bool {
+	if job.state != jobStateQueued {
+		// Already running or finished, so shouldn't be run again.
+		return false
+	}
+
+	// Check dependencies.
+	for _, dep := range job.dependencies {
+		if dep.state != jobStateFinished {
+			// A dependency is not finished, so this job has to wait until it
+			// is.
+			return false
+		}
+	}
+
+	// All conditions are satisfied.
+	return true
+}
+
+// runJobs runs the indicated job and all its dependencies. For every job, all
+// the dependencies are run first. It returns the error of the first job that
+// fails.
+// It runs all jobs in the order of the dependencies slice, depth-first.
+// Therefore, if some jobs are preferred to run before others, they should be
+// ordered as such in the job dependencies.
+func runJobs(job *compileJob, parallelism int) error {
+	if parallelism == 0 {
+		// Have a default, if the parallelism isn't set. This is useful for
+		// tests.
+		parallelism = runtime.NumCPU()
+	}
+	if parallelism < 1 {
+		return fmt.Errorf("-p flag must be at least 1, provided -p=%d", parallelism)
+	}
+
+	// Create a slice of jobs to run, where all dependencies are run in order.
+	jobs := []*compileJob{}
+	addedJobs := map[*compileJob]struct{}{}
+	var addJobs func(*compileJob)
+	addJobs = func(job *compileJob) {
+		if _, ok := addedJobs[job]; ok {
+			return
+		}
+		for _, dep := range job.dependencies {
+			addJobs(dep)
+		}
+		jobs = append(jobs, job)
+		addedJobs[job] = struct{}{}
+	}
+	addJobs(job)
+
+	// Create channels to communicate with the workers.
+	doneChan := make(chan *compileJob)
+	workerChan := make(chan *compileJob)
+	defer close(workerChan)
+
+	// Start a number of workers.
+	for i := 0; i < parallelism; i++ {
+		if jobRunnerDebug {
+			fmt.Println("## starting worker", i)
+		}
+		go jobWorker(workerChan, doneChan)
+	}
+
+	// Send each job in the jobs slice to a worker, taking care of job
+	// dependencies.
+	numRunningJobs := 0
+	var totalTime time.Duration
+	start := time.Now()
+	for {
+		// If there are free workers, try starting a new job (if one is
+		// available). If it succeeds, try again to fill the entire worker pool.
+		if numRunningJobs < parallelism {
+			jobToRun := nextJob(jobs)
+			if jobToRun != nil {
+				// Start job.
+				if jobRunnerDebug {
+					fmt.Println("## start:   ", jobToRun.description)
+				}
+				jobToRun.state = jobStateRunning
+				workerChan <- jobToRun
+				numRunningJobs++
+				continue
+			}
+		}
+
+		// When there are no jobs running, all jobs in the jobs slice must have
+		// been finished. Therefore, the work is done.
+		if numRunningJobs == 0 {
+			break
+		}
+
+		// Wait until a job is finished.
+		job := <-doneChan
+		job.state = jobStateFinished
+		numRunningJobs--
+		totalTime += job.duration
+		if jobRunnerDebug {
+			fmt.Println("## finished:", job.description, "(time "+job.duration.String()+")")
+		}
+		if job.err != nil {
+			// Wait for running jobs to finish.
+			for numRunningJobs != 0 {
+				<-doneChan
+				numRunningJobs--
+			}
+			// Return error of first failing job.
+			return job.err
+		}
+	}
+
+	// Some statistics, if debugging.
+	if jobRunnerDebug {
+		// Total duration of running all jobs.
+		duration := time.Since(start)
+		fmt.Println("## total:   ", duration)
+
+		// The individual time of each job combined. On a multicore system, this
+		// should be lower than the total above.
+		fmt.Println("## job sum: ", totalTime)
+	}
+
+	return nil
+}
+
+// nextJob returns the first ready-to-run job.
+// This is an implementation detail of runJobs.
+func nextJob(jobs []*compileJob) *compileJob {
+	for _, job := range jobs {
+		if job.readyToRun() {
+			return job
+		}
+	}
+	return nil
+}
+
+// jobWorker is the goroutine that runs received jobs.
+// This is an implementation detail of runJobs.
+func jobWorker(workerChan, doneChan chan *compileJob) {
+	for job := range workerChan {
+		start := time.Now()
+		if job.run != nil {
+			err := job.run(job)
+			if err != nil {
+				job.err = err
+			}
+		}
+		job.duration = time.Since(start)
+		doneChan <- job
+	}
+}

builder/library.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
 )
 
@@ -15,59 +16,109 @@ type Library struct {
 	// The library name, such as compiler-rt or picolibc.
 	name string
 
-	cflags func() []string
+	// makeHeaders creates a header include dir for the library
+	makeHeaders func(target, includeDir string) error
+
+	// cflags returns the C flags specific to this library
+	cflags func(target, headerPath string) []string
 
 	// The source directory, relative to TINYGOROOT.
 	sourceDir string
 
 	// The source files, relative to sourceDir.
-	sources func(target string) []string
-}
+	librarySources func(target string) []string
 
-// fullPath returns the full path to the source directory.
-func (l *Library) fullPath() string {
-	return filepath.Join(goenv.Get("TINYGOROOT"), l.sourceDir)
-}
-
-// sourcePaths returns a slice with the full paths to the source files.
-func (l *Library) sourcePaths(target string) []string {
-	sources := l.sources(target)
-	paths := make([]string, len(sources))
-	for i, name := range sources {
-		paths[i] = filepath.Join(l.fullPath(), name)
-	}
-	return paths
+	// The source code for the crt1.o file, relative to sourceDir.
+	crt1Source string
 }
 
 // Load the library archive, possibly generating and caching it if needed.
-func (l *Library) Load(target string) (path string, err error) {
-	// Try to load a precompiled library.
-	precompiledPath := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", target, l.name+".a")
-	if _, err := os.Stat(precompiledPath); err == nil {
-		// Found a precompiled library for this OS/architecture. Return the path
-		// directly.
-		return precompiledPath, nil
-	}
-
-	outfile := l.name + "-" + target + ".a"
-
-	// Try to fetch this library from the cache.
-	if path, err := cacheLoad(outfile, commands["clang"][0], l.sourcePaths(target)); path != "" || err != nil {
-		// Cache hit.
-		return path, err
-	}
-	// Cache miss, build it now.
-
-	dirPrefix := "tinygo-" + l.name
-	remapDir := filepath.Join(os.TempDir(), dirPrefix)
-	dir, err := ioutil.TempDir(os.TempDir(), dirPrefix)
+// The resulting directory may be stored in the provided tmpdir, which is
+// expected to be removed after the Load call.
+func (l *Library) Load(config *compileopts.Config, tmpdir string) (dir string, err error) {
+	job, err := l.load(config, tmpdir)
 	if err != nil {
 		return "", err
 	}
-	defer os.RemoveAll(dir)
+	err = runJobs(job, config.Options.Parallelism)
+	return filepath.Dir(job.result), err
+}
+
+// load returns a compile job to build this library file for the given target
+// and CPU. It may return a dummy compileJob if the library build is already
+// cached. The path is stored as job.result but is only valid after the job has
+// been run.
+// The provided tmpdir will be used to store intermediary files and possibly the
+// output archive file, it is expected to be removed after use.
+// As a side effect, this call creates the library header files if they didn't
+// exist yet.
+func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJob, err error) {
+	outdir, precompiled := config.LibcPath(l.name)
+	archiveFilePath := filepath.Join(outdir, "lib.a")
+	if precompiled {
+		// Found a precompiled library for this OS/architecture. Return the path
+		// directly.
+		return dummyCompileJob(archiveFilePath), nil
+	}
+
+	// Try to fetch this library from the cache.
+	if _, err := os.Stat(archiveFilePath); err == nil {
+		return dummyCompileJob(archiveFilePath), nil
+	}
+	// Cache miss, build it now.
+
+	// Create the destination directory where the components of this library
+	// (lib.a file, include directory) are placed.
+	outname := filepath.Base(outdir)
+	err = os.MkdirAll(filepath.Join(goenv.Get("GOCACHE"), outname), 0o777)
+	if err != nil {
+		// Could not create directory (and not because it already exists).
+		return nil, err
+	}
+
+	// Make headers if needed.
+	headerPath := filepath.Join(outdir, "include")
+	target := config.Triple()
+	if l.makeHeaders != nil {
+		if _, err = os.Stat(headerPath); err != nil {
+			temporaryHeaderPath, err := ioutil.TempDir(outdir, "include.tmp*")
+			if err != nil {
+				return nil, err
+			}
+			defer os.RemoveAll(temporaryHeaderPath)
+			err = l.makeHeaders(target, temporaryHeaderPath)
+			if err != nil {
+				return nil, err
+			}
+			err = os.Rename(temporaryHeaderPath, headerPath)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	remapDir := filepath.Join(os.TempDir(), "tinygo-"+l.name)
+	dir := filepath.Join(tmpdir, "build-lib-"+l.name)
+	err = os.Mkdir(dir, 0777)
+	if err != nil {
+		return nil, err
+	}
 
 	// Precalculate the flags to the compiler invocation.
-	args := append(l.cflags(), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
+	// 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.
+	args := append(l.cflags(target, headerPath), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
+	cpu := config.CPU()
+	if cpu != "" {
+		// X86 has deprecated the -mcpu flag, so we need to use -march instead.
+		// However, ARM has not done this.
+		if strings.HasPrefix(target, "i386") || strings.HasPrefix(target, "x86_64") {
+			args = append(args, "-march="+cpu)
+		} else {
+			args = append(args, "-mcpu="+cpu)
+		}
+	}
 	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
 		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft")
 	}
@@ -78,28 +129,83 @@ func (l *Library) Load(target string) (path string, err error) {
 		args = append(args, "-march=rv64gc", "-mabi=lp64")
 	}
 
-	// Compile all sources.
+	// Create job to put all the object files in a single archive. This archive
+	// file is the (static) library file.
 	var objs []string
-	for _, srcpath := range l.sourcePaths(target) {
-		objpath := filepath.Join(dir, filepath.Base(srcpath)+".o")
-		objs = append(objs, objpath)
-		// 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.
-		err := runCCompiler("clang", append(args, "-o", objpath, srcpath)...)
-		if err != nil {
-			return "", &commandError{"failed to build", srcpath, err}
+	job = &compileJob{
+		description: "ar " + l.name + "/lib.a",
+		result:      filepath.Join(goenv.Get("GOCACHE"), outname, "lib.a"),
+		run: func(*compileJob) error {
+			// Create an archive of all object files.
+			f, err := ioutil.TempFile(outdir, "libc.a.tmp*")
+			if err != nil {
+				return err
+			}
+			err = makeArchive(f, objs)
+			if err != nil {
+				return err
+			}
+			err = f.Close()
+			if err != nil {
+				return err
+			}
+			// Store this archive in the cache.
+			return os.Rename(f.Name(), archiveFilePath)
+		},
+	}
+
+	// Create jobs to compile all sources. These jobs are depended upon by the
+	// archive job above, so must be run first.
+	for _, path := range l.librarySources(target) {
+		// Strip leading "../" parts off the path.
+		cleanpath := path
+		for strings.HasPrefix(cleanpath, "../") {
+			cleanpath = cleanpath[3:]
 		}
+		srcpath := filepath.Join(goenv.Get("TINYGOROOT"), l.sourceDir, path)
+		objpath := filepath.Join(dir, cleanpath+".o")
+		os.MkdirAll(filepath.Dir(objpath), 0o777)
+		objs = append(objs, objpath)
+		job.dependencies = append(job.dependencies, &compileJob{
+			description: "compile " + srcpath,
+			run: func(*compileJob) error {
+				var compileArgs []string
+				compileArgs = append(compileArgs, args...)
+				compileArgs = append(compileArgs, "-o", objpath, srcpath)
+				err := runCCompiler(compileArgs...)
+				if err != nil {
+					return &commandError{"failed to build", srcpath, err}
+				}
+				return nil
+			},
+		})
 	}
 
-	// Put all the object files in a single archive. This archive file will be
-	// used to statically link this library.
-	arpath := filepath.Join(dir, l.name+".a")
-	err = makeArchive(arpath, objs)
-	if err != nil {
-		return "", err
+	// Create crt1.o job, if needed.
+	// Add this as a (fake) dependency to the ar file so it gets compiled.
+	// (It could be done in parallel with creating the ar file, but it probably
+	// won't make much of a difference in speed).
+	if l.crt1Source != "" {
+		srcpath := filepath.Join(goenv.Get("TINYGOROOT"), l.sourceDir, l.crt1Source)
+		job.dependencies = append(job.dependencies, &compileJob{
+			description: "compile " + srcpath,
+			run: func(*compileJob) error {
+				var compileArgs []string
+				compileArgs = append(compileArgs, args...)
+				tmpfile, err := ioutil.TempFile(outdir, "crt1.o.tmp*")
+				if err != nil {
+					return err
+				}
+				tmpfile.Close()
+				compileArgs = append(compileArgs, "-o", tmpfile.Name(), srcpath)
+				err = runCCompiler(compileArgs...)
+				if err != nil {
+					return &commandError{"failed to build", srcpath, err}
+				}
+				return os.Rename(tmpfile.Name(), filepath.Join(outdir, "crt1.o"))
+			},
+		})
 	}
 
-	// Store this archive in the cache.
-	return cacheStore(arpath, outfile, commands["clang"][0], l.sourcePaths(target))
+	return job, nil
 }

builder/musl.go

@@ -0,0 +1,162 @@
+package builder
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+var Musl = Library{
+	name: "musl",
+	makeHeaders: func(target, includeDir string) error {
+		bits := filepath.Join(includeDir, "bits")
+		err := os.Mkdir(bits, 0777)
+		if err != nil {
+			return err
+		}
+
+		arch := compileopts.MuslArchitecture(target)
+		muslDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib", "musl")
+
+		// Create the file alltypes.h.
+		f, err := os.Create(filepath.Join(bits, "alltypes.h"))
+		if err != nil {
+			return err
+		}
+		infiles := []string{
+			filepath.Join(muslDir, "arch", arch, "bits", "alltypes.h.in"),
+			filepath.Join(muslDir, "include", "alltypes.h.in"),
+		}
+		for _, infile := range infiles {
+			data, err := ioutil.ReadFile(infile)
+			if err != nil {
+				return err
+			}
+			lines := strings.Split(string(data), "\n")
+			for _, line := range lines {
+				if strings.HasPrefix(line, "TYPEDEF ") {
+					matches := regexp.MustCompile(`TYPEDEF (.*) ([^ ]*);`).FindStringSubmatch(line)
+					value := matches[1]
+					name := matches[2]
+					line = fmt.Sprintf("#if defined(__NEED_%s) && !defined(__DEFINED_%s)\ntypedef %s %s;\n#define __DEFINED_%s\n#endif\n", name, name, value, name, name)
+				}
+				if strings.HasPrefix(line, "STRUCT ") {
+					matches := regexp.MustCompile(`STRUCT * ([^ ]*) (.*);`).FindStringSubmatch(line)
+					name := matches[1]
+					value := matches[2]
+					line = fmt.Sprintf("#if defined(__NEED_struct_%s) && !defined(__DEFINED_struct_%s)\nstruct %s %s;\n#define __DEFINED_struct_%s\n#endif\n", name, name, name, value, name)
+				}
+				f.WriteString(line + "\n")
+			}
+		}
+		f.Close()
+
+		// Create the file syscall.h.
+		f, err = os.Create(filepath.Join(bits, "syscall.h"))
+		if err != nil {
+			return err
+		}
+		data, err := ioutil.ReadFile(filepath.Join(muslDir, "arch", arch, "bits", "syscall.h.in"))
+		if err != nil {
+			return err
+		}
+		_, err = f.Write(bytes.ReplaceAll(data, []byte("__NR_"), []byte("SYS_")))
+		if err != nil {
+			return err
+		}
+		f.Close()
+
+		return nil
+	},
+	cflags: func(target, headerPath string) []string {
+		arch := compileopts.MuslArchitecture(target)
+		muslDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/musl")
+		return []string{
+			"-std=c99",            // same as in musl
+			"-D_XOPEN_SOURCE=700", // same as in musl
+			// Musl triggers some warnings and we don't want to show any
+			// warnings while compiling (only errors or silence), so disable
+			// specific warnings that are triggered in musl.
+			"-Werror",
+			"-Wno-logical-op-parentheses",
+			"-Wno-bitwise-op-parentheses",
+			"-Wno-shift-op-parentheses",
+			"-Wno-ignored-attributes",
+			"-Wno-string-plus-int",
+			"-Qunused-arguments",
+			// Select include dirs. Don't include standard library includes
+			// (that would introduce host dependencies and other complications),
+			// but do include all the include directories expected by musl.
+			"-nostdlibinc",
+			"-I" + muslDir + "/arch/" + arch,
+			"-I" + muslDir + "/arch/generic",
+			"-I" + muslDir + "/src/include",
+			"-I" + muslDir + "/src/internal",
+			"-I" + headerPath,
+			"-I" + muslDir + "/include",
+		}
+	},
+	sourceDir: "lib/musl/src",
+	librarySources: func(target string) []string {
+		arch := compileopts.MuslArchitecture(target)
+		globs := []string{
+			"env/*.c",
+			"errno/*.c",
+			"exit/*.c",
+			"internal/defsysinfo.c",
+			"internal/libc.c",
+			"internal/syscall_ret.c",
+			"internal/vdso.c",
+			"malloc/*.c",
+			"mman/*.c",
+			"signal/*.c",
+			"stdio/*.c",
+			"string/*.c",
+			"thread/" + arch + "/*.s",
+			"thread/" + arch + "/*.c",
+			"thread/*.c",
+			"time/*.c",
+			"unistd/*.c",
+		}
+
+		var sources []string
+		seenSources := map[string]struct{}{}
+		basepath := goenv.Get("TINYGOROOT") + "/lib/musl/src/"
+		for _, pattern := range globs {
+			matches, err := filepath.Glob(basepath + pattern)
+			if err != nil {
+				// From the documentation:
+				// > Glob ignores file system errors such as I/O errors reading
+				// > directories. The only possible returned error is
+				// > ErrBadPattern, when pattern is malformed.
+				// So the only possible error is when the (statically defined)
+				// pattern is wrong. In other words, a programming bug.
+				panic("could not glob source dirs: " + err.Error())
+			}
+			for _, match := range matches {
+				relpath, err := filepath.Rel(basepath, match)
+				if err != nil {
+					// Not sure if this is even possible.
+					panic(err)
+				}
+				// Make sure architecture specific files override generic files.
+				id := strings.ReplaceAll(relpath, "/"+arch+"/", "/")
+				if _, ok := seenSources[id]; ok {
+					// Already seen this file, skipping this (generic) file.
+					continue
+				}
+				seenSources[id] = struct{}{}
+				sources = append(sources, relpath)
+			}
+		}
+		return sources
+	},
+	crt1Source: "../crt/crt1.c", // lib/musl/crt/crt1.c
+}

builder/nrfutil.go

@@ -0,0 +1,27 @@
+package builder
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os/exec"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+)
+
+// https://infocenter.nordicsemi.com/index.jsp?topic=%2Fug_nrfutil%2FUG%2Fnrfutil%2Fnrfutil_intro.html
+
+func makeDFUFirmwareImage(options *compileopts.Options, infile, outfile string) error {
+	cmdLine := []string{"nrfutil", "pkg", "generate", "--hw-version", "52", "--sd-req", "0x0", "--debug-mode", "--application", infile, outfile}
+
+	if options.PrintCommands != nil {
+		options.PrintCommands(cmdLine[0], cmdLine[1:]...)
+	}
+
+	cmd := exec.Command(cmdLine[0], cmdLine[1:]...)
+	cmd.Stdout = ioutil.Discard
+	err := cmd.Run()
+	if err != nil {
+		return fmt.Errorf("could not run nrfutil pkg generate: %w", err)
+	}
+	return nil
+}

builder/picolibc.go

@@ -1,6 +1,7 @@
 package builder
 
 import (
+	"os"
 	"path/filepath"
 
 	"github.com/tinygo-org/tinygo/goenv"
@@ -10,17 +11,134 @@ import (
 // based on newlib.
 var Picolibc = Library{
 	name: "picolibc",
-	cflags: func() []string {
+	makeHeaders: func(target, includeDir string) error {
+		f, err := os.Create(filepath.Join(includeDir, "picolibc.h"))
+		if err != nil {
+			return err
+		}
+		return f.Close()
+	},
+	cflags: func(target, headerPath string) []string {
 		picolibcDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib/libc")
-		return []string{"-Werror", "-Wall", "-std=gnu11", "-D_COMPILING_NEWLIB", "-nostdlibinc", "-Xclang", "-internal-isystem", "-Xclang", picolibcDir + "/include", "-I" + picolibcDir + "/tinystdio", "-I" + goenv.Get("TINYGOROOT") + "/lib/picolibc-include"}
+		return []string{
+			"-Werror",
+			"-Wall",
+			"-std=gnu11",
+			"-D_COMPILING_NEWLIB",
+			"-DHAVE_ALIAS_ATTRIBUTE",
+			"-DTINY_STDIO",
+			"-nostdlibinc",
+			"-Xclang", "-internal-isystem", "-Xclang", picolibcDir + "/include",
+			"-I" + picolibcDir + "/tinystdio",
+			"-I" + headerPath,
+		}
 	},
 	sourceDir: "lib/picolibc/newlib/libc",
-	sources: func(target string) []string {
+	librarySources: func(target string) []string {
 		return picolibcSources
 	},
 }
 
 var picolibcSources = []string{
+	"../../../picolibc-stdio.c",
+
+	"tinystdio/asprintf.c",
+	"tinystdio/atod_engine.c",
+	"tinystdio/atod_ryu.c",
+	"tinystdio/atof_engine.c",
+	"tinystdio/atof_ryu.c",
+	//"tinystdio/atold_engine.c", // have_long_double and not long_double_equals_double
+	"tinystdio/clearerr.c",
+	"tinystdio/compare_exchange.c",
+	"tinystdio/dtoa_data.c",
+	"tinystdio/dtoa_engine.c",
+	"tinystdio/dtoa_ryu.c",
+	"tinystdio/ecvtbuf.c",
+	"tinystdio/ecvt.c",
+	"tinystdio/ecvt_data.c",
+	"tinystdio/ecvtfbuf.c",
+	"tinystdio/ecvtf.c",
+	"tinystdio/ecvtf_data.c",
+	"tinystdio/exchange.c",
+	//"tinystdio/fclose.c", // posix-io
+	"tinystdio/fcvtbuf.c",
+	"tinystdio/fcvt.c",
+	"tinystdio/fcvtfbuf.c",
+	"tinystdio/fcvtf.c",
+	"tinystdio/fdevopen.c",
+	//"tinystdio/fdopen.c", // posix-io
+	"tinystdio/feof.c",
+	"tinystdio/ferror.c",
+	"tinystdio/fflush.c",
+	"tinystdio/fgetc.c",
+	"tinystdio/fgets.c",
+	"tinystdio/fileno.c",
+	"tinystdio/filestrget.c",
+	"tinystdio/filestrputalloc.c",
+	"tinystdio/filestrput.c",
+	//"tinystdio/fopen.c", // posix-io
+	"tinystdio/fprintf.c",
+	"tinystdio/fputc.c",
+	"tinystdio/fputs.c",
+	"tinystdio/fread.c",
+	"tinystdio/fscanf.c",
+	"tinystdio/fseek.c",
+	"tinystdio/ftell.c",
+	"tinystdio/ftoa_data.c",
+	"tinystdio/ftoa_engine.c",
+	"tinystdio/ftoa_ryu.c",
+	"tinystdio/fwrite.c",
+	"tinystdio/gcvtbuf.c",
+	"tinystdio/gcvt.c",
+	"tinystdio/gcvtfbuf.c",
+	"tinystdio/gcvtf.c",
+	"tinystdio/getchar.c",
+	"tinystdio/gets.c",
+	"tinystdio/matchcaseprefix.c",
+	"tinystdio/perror.c",
+	//"tinystdio/posixiob.c", // posix-io
+	//"tinystdio/posixio.c", // posix-io
+	"tinystdio/printf.c",
+	"tinystdio/putchar.c",
+	"tinystdio/puts.c",
+	"tinystdio/ryu_divpow2.c",
+	"tinystdio/ryu_log10.c",
+	"tinystdio/ryu_log2pow5.c",
+	"tinystdio/ryu_pow5bits.c",
+	"tinystdio/ryu_table.c",
+	"tinystdio/ryu_umul128.c",
+	"tinystdio/scanf.c",
+	"tinystdio/setbuf.c",
+	"tinystdio/setvbuf.c",
+	//"tinystdio/sflags.c", // posix-io
+	"tinystdio/snprintf.c",
+	"tinystdio/snprintfd.c",
+	"tinystdio/snprintff.c",
+	"tinystdio/sprintf.c",
+	"tinystdio/sprintfd.c",
+	"tinystdio/sprintff.c",
+	"tinystdio/sscanf.c",
+	"tinystdio/strfromd.c",
+	"tinystdio/strfromf.c",
+	"tinystdio/strtod.c",
+	"tinystdio/strtod_l.c",
+	"tinystdio/strtof.c",
+	//"tinystdio/strtold.c",   // have_long_double and not long_double_equals_double
+	//"tinystdio/strtold_l.c", // have_long_double and not long_double_equals_double
+	"tinystdio/ungetc.c",
+	"tinystdio/vasprintf.c",
+	"tinystdio/vfiprintf.c",
+	"tinystdio/vfiscanf.c",
+	"tinystdio/vfprintf.c",
+	"tinystdio/vfprintff.c",
+	"tinystdio/vfscanf.c",
+	"tinystdio/vfscanff.c",
+	"tinystdio/vprintf.c",
+	"tinystdio/vscanf.c",
+	"tinystdio/vsnprintf.c",
+	"tinystdio/vsprintf.c",
+	"tinystdio/vsscanf.c",
+
 	"string/bcmp.c",
 	"string/bcopy.c",
 	"string/bzero.c",

builder/sizes.go

@@ -1,16 +1,30 @@
 package builder
 
 import (
+	"bytes"
+	"debug/dwarf"
 	"debug/elf"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
 	"sort"
 	"strings"
+
+	"github.com/aykevl/go-wasm"
+	"github.com/tinygo-org/tinygo/goenv"
 )
 
+// Set to true to print extra debug logs.
+const sizesDebug = false
+
 // programSize contains size statistics per package of a compiled program.
 type programSize struct {
-	Packages map[string]*packageSize
-	Sum      *packageSize
+	Packages map[string]packageSize
 	Code     uint64
+	ROData   uint64
 	Data     uint64
 	BSS      uint64
 }
@@ -26,6 +40,16 @@ func (ps *programSize) sortedPackageNames() []string {
 	return names
 }
 
+// Flash usage in regular microcontrollers.
+func (ps *programSize) Flash() uint64 {
+	return ps.Code + ps.ROData + ps.Data
+}
+
+// Static RAM usage in regular microcontrollers.
+func (ps *programSize) RAM() uint64 {
+	return ps.Data + ps.BSS
+}
+
 // packageSize contains the size of a package, calculated from the linked object
 // file.
 type packageSize struct {
@@ -45,129 +69,520 @@ func (ps *packageSize) RAM() uint64 {
 	return ps.Data + ps.BSS
 }
 
-type symbolList []elf.Symbol
-
-func (l symbolList) Len() int {
-	return len(l)
+// A mapping of a single chunk of code or data to a file path.
+type addressLine struct {
+	Address    uint64
+	Length     uint64 // length of this chunk
+	File       string // file path as stored in DWARF
+	IsVariable bool   // true if this is a variable (or constant), false if it is code
 }
 
-func (l symbolList) Less(i, j int) bool {
-	bind_i := elf.ST_BIND(l[i].Info)
-	bind_j := elf.ST_BIND(l[j].Info)
-	if l[i].Value == l[j].Value && bind_i != elf.STB_WEAK && bind_j == elf.STB_WEAK {
-		// sort weak symbols after non-weak symbols
-		return true
+// Sections defined in the input file. This struct defines them in a
+// filetype-agnostic way but roughly follow the ELF types (.text, .data, .bss,
+// etc).
+type memorySection struct {
+	Type    memoryType
+	Address uint64
+	Size    uint64
+}
+
+type memoryType int
+
+const (
+	memoryCode memoryType = iota + 1
+	memoryData
+	memoryROData
+	memoryBSS
+	memoryStack
+)
+
+// Regular expressions to match particular symbol names. These are not stored as
+// DWARF variables because they have no mapping to source code global variables.
+var (
+	// Various globals that aren't a variable but nonetheless need to be stored
+	// somewhere:
+	//   alloc:  heap allocations during init interpretation
+	//   pack:   data created when storing a constant in an interface for example
+	//   string: buffer behind strings
+	packageSymbolRegexp = regexp.MustCompile(`\$(alloc|pack|string)(\.[0-9]+)?$`)
+
+	// Reflect sidetables. Created by the reflect lowering pass.
+	// See src/reflect/sidetables.go.
+	reflectDataRegexp = regexp.MustCompile(`^reflect\.[a-zA-Z]+Sidetable$`)
+)
+
+// readProgramSizeFromDWARF reads the source location for each line of code and
+// each variable in the program, as far as this is stored in the DWARF debug
+// information.
+func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64) ([]addressLine, error) {
+	r := data.Reader()
+	var lines []*dwarf.LineFile
+	var addresses []addressLine
+	for {
+		e, err := r.Next()
+		if err != nil {
+			return nil, err
+		}
+		if e == nil {
+			break
+		}
+		switch e.Tag {
+		case dwarf.TagCompileUnit:
+			// Found a compile unit.
+			// We can read the .debug_line section using it, which contains a
+			// mapping for most instructions to their file/line/column - even
+			// for inlined functions!
+			lr, err := data.LineReader(e)
+			if err != nil {
+				return nil, err
+			}
+			lines = lr.Files()
+			var lineEntry = dwarf.LineEntry{
+				EndSequence: true,
+			}
+
+			// Line tables are organized as sequences of line entries until an
+			// end sequence. A single line table can contain multiple such
+			// sequences. The last line entry is an EndSequence to indicate the
+			// end.
+			for {
+				// Read the next .debug_line entry.
+				prevLineEntry := lineEntry
+				err := lr.Next(&lineEntry)
+				if err != nil {
+					if err == io.EOF {
+						break
+					}
+					return nil, err
+				}
+
+				if prevLineEntry.EndSequence && lineEntry.Address == 0 {
+					// Tombstone value. This symbol has been removed, for
+					// example by the --gc-sections linker flag. It is still
+					// here in the debug information because the linker can't
+					// just remove this reference.
+					// Read until the next EndSequence so that this sequence is
+					// skipped.
+					// For more details, see (among others):
+					// https://reviews.llvm.org/D84825
+					for {
+						err := lr.Next(&lineEntry)
+						if err != nil {
+							return nil, err
+						}
+						if lineEntry.EndSequence {
+							break
+						}
+					}
+				}
+
+				if !prevLineEntry.EndSequence {
+					// The chunk describes the code from prevLineEntry to
+					// lineEntry.
+					line := addressLine{
+						Address: prevLineEntry.Address + codeOffset,
+						Length:  lineEntry.Address - prevLineEntry.Address,
+						File:    prevLineEntry.File.Name,
+					}
+					if line.Length != 0 {
+						addresses = append(addresses, line)
+					}
+				}
+			}
+		case dwarf.TagVariable:
+			// Global variable (or constant). Most of these are not actually
+			// stored in the binary, because they have been optimized out. Only
+			// the ones with a location are still present.
+			r.SkipChildren()
+
+			file := e.AttrField(dwarf.AttrDeclFile)
+			location := e.AttrField(dwarf.AttrLocation)
+			globalType := e.AttrField(dwarf.AttrType)
+			if file == nil || location == nil || globalType == nil {
+				// Doesn't contain the requested information.
+				continue
+			}
+
+			// Try to parse the location. While this could in theory be a very
+			// complex expression, usually it's just a DW_OP_addr opcode
+			// followed by an address.
+			locationCode := location.Val.([]uint8)
+			if locationCode[0] != 3 { // DW_OP_addr
+				continue
+			}
+			var addr uint64
+			switch len(locationCode) {
+			case 1 + 2:
+				addr = uint64(binary.LittleEndian.Uint16(locationCode[1:]))
+			case 1 + 4:
+				addr = uint64(binary.LittleEndian.Uint32(locationCode[1:]))
+			case 1 + 8:
+				addr = binary.LittleEndian.Uint64(locationCode[1:])
+			default:
+				continue // unknown address
+			}
+
+			// Parse the type of the global variable, which (importantly)
+			// contains the variable size. We're not interested in the type,
+			// only in the size.
+			typ, err := data.Type(globalType.Val.(dwarf.Offset))
+			if err != nil {
+				return nil, err
+			}
+
+			addresses = append(addresses, addressLine{
+				Address:    addr,
+				Length:     uint64(typ.Size()),
+				File:       lines[file.Val.(int64)].Name,
+				IsVariable: true,
+			})
+		default:
+			r.SkipChildren()
+		}
 	}
-	return l[i].Value < l[j].Value
-}
-
-func (l symbolList) Swap(i, j int) {
-	l[i], l[j] = l[j], l[i]
+	return addresses, nil
 }
 
 // loadProgramSize calculate a program/data size breakdown of each package for a
 // given ELF file.
-func loadProgramSize(path string) (*programSize, error) {
-	file, err := elf.Open(path)
+// If the file doesn't contain DWARF debug information, the returned program
+// size will still have valid summaries but won't have complete size information
+// per package.
+func loadProgramSize(path string, packagePathMap map[string]string) (*programSize, error) {
+	// Open the binary file.
+	f, err := os.Open(path)
 	if err != nil {
 		return nil, err
 	}
-	defer file.Close()
+	defer f.Close()
 
-	var sumCode uint64
-	var sumData uint64
-	var sumBSS uint64
-	for _, section := range file.Sections {
-		if section.Flags&elf.SHF_ALLOC == 0 {
-			continue
-		}
-		if section.Type != elf.SHT_PROGBITS && section.Type != elf.SHT_NOBITS {
-			continue
-		}
-		if section.Name == ".stack" {
-			// HACK: this works around a bug in ld.lld from LLVM 10. The linker
-			// marks sections with no input symbols (such as is the case for the
-			// .stack section) as SHT_PROGBITS instead of SHT_NOBITS. While it
-			// doesn't affect the generated binaries (.hex and .bin), it does
-			// affect the reported size.
-			// https://bugs.llvm.org/show_bug.cgi?id=45336
-			// https://reviews.llvm.org/D76981
-			// It has been merged in master, but it has not (yet) been
-			// backported to the LLVM 10 release branch.
-			sumBSS += section.Size
-		} else if section.Type == elf.SHT_NOBITS {
-			sumBSS += section.Size
-		} else if section.Flags&elf.SHF_EXECINSTR != 0 {
-			sumCode += section.Size
-		} else if section.Flags&elf.SHF_WRITE != 0 {
-			sumData += section.Size
-		}
-	}
+	// This stores all chunks of addresses found in the binary.
+	var addresses []addressLine
 
-	allSymbols, err := file.Symbols()
-	if err != nil {
-		return nil, err
-	}
-	symbols := make([]elf.Symbol, 0, len(allSymbols))
-	for _, symbol := range allSymbols {
-		symType := elf.ST_TYPE(symbol.Info)
-		if symbol.Size == 0 {
-			continue
-		}
-		if symType != elf.STT_FUNC && symType != elf.STT_OBJECT && symType != elf.STT_NOTYPE {
-			continue
-		}
-		if symbol.Section >= elf.SectionIndex(len(file.Sections)) {
-			continue
-		}
-		section := file.Sections[symbol.Section]
-		if section.Flags&elf.SHF_ALLOC == 0 {
-			continue
-		}
-		symbols = append(symbols, symbol)
-	}
-	sort.Sort(symbolList(symbols))
-
-	sizes := map[string]*packageSize{}
-	var lastSymbolValue uint64
-	for _, symbol := range symbols {
-		symType := elf.ST_TYPE(symbol.Info)
-		//bind := elf.ST_BIND(symbol.Info)
-		section := file.Sections[symbol.Section]
-		pkgName := "(bootstrap)"
-		symName := strings.TrimLeft(symbol.Name, "(*")
-		dot := strings.IndexByte(symName, '.')
-		if dot > 0 {
-			pkgName = symName[:dot]
-		}
-		pkgSize := sizes[pkgName]
-		if pkgSize == nil {
-			pkgSize = &packageSize{}
-			sizes[pkgName] = pkgSize
-		}
-		if lastSymbolValue != symbol.Value || lastSymbolValue == 0 {
-			if symType == elf.STT_FUNC {
-				pkgSize.Code += symbol.Size
-			} else if section.Flags&elf.SHF_WRITE != 0 {
-				if section.Type == elf.SHT_NOBITS {
-					pkgSize.BSS += symbol.Size
-				} else {
-					pkgSize.Data += symbol.Size
-				}
-			} else {
-				pkgSize.ROData += symbol.Size
+	// Load the binary file, which could be in a number of file formats.
+	var sections []memorySection
+	if file, err := elf.NewFile(f); err == nil {
+		// Read DWARF information. The error is intentionally ignored.
+		data, _ := file.DWARF()
+		if data != nil {
+			addresses, err = readProgramSizeFromDWARF(data, 0)
+			if err != nil {
+				// However, _do_ report an error here. Something must have gone
+				// wrong while trying to parse DWARF data.
+				return nil, err
 			}
 		}
-		lastSymbolValue = symbol.Value
+
+		// Read the ELF symbols for some more chunks of location information.
+		// Some globals (such as strings) aren't stored in the DWARF debug
+		// information and therefore need to be obtained in a different way.
+		allSymbols, err := file.Symbols()
+		if err != nil {
+			return nil, err
+		}
+		for _, symbol := range allSymbols {
+			symType := elf.ST_TYPE(symbol.Info)
+			if symbol.Size == 0 {
+				continue
+			}
+			if symType != elf.STT_FUNC && symType != elf.STT_OBJECT && symType != elf.STT_NOTYPE {
+				continue
+			}
+			section := file.Sections[symbol.Section]
+			if section.Flags&elf.SHF_ALLOC == 0 {
+				continue
+			}
+			if packageSymbolRegexp.MatchString(symbol.Name) || reflectDataRegexp.MatchString(symbol.Name) {
+				addresses = append(addresses, addressLine{
+					Address:    symbol.Value,
+					Length:     symbol.Size,
+					File:       symbol.Name,
+					IsVariable: true,
+				})
+			}
+		}
+
+		// Load allocated sections.
+		for _, section := range file.Sections {
+			if section.Flags&elf.SHF_ALLOC == 0 {
+				continue
+			}
+			if section.Type == elf.SHT_NOBITS {
+				if section.Name == ".stack" {
+					// TinyGo emits stack sections on microcontroller using the
+					// ".stack" name.
+					// This is a bit ugly, but I don't think there is a way to
+					// mark the stack section in a linker script.
+					sections = append(sections, memorySection{
+						Address: section.Addr,
+						Size:    section.Size,
+						Type:    memoryStack,
+					})
+				} else {
+					// Regular .bss section.
+					sections = append(sections, memorySection{
+						Address: section.Addr,
+						Size:    section.Size,
+						Type:    memoryBSS,
+					})
+				}
+			} else if section.Type == elf.SHT_PROGBITS && section.Flags&elf.SHF_EXECINSTR != 0 {
+				// .text
+				sections = append(sections, memorySection{
+					Address: section.Addr,
+					Size:    section.Size,
+					Type:    memoryCode,
+				})
+			} else if section.Type == elf.SHT_PROGBITS && section.Flags&elf.SHF_WRITE != 0 {
+				// .data
+				sections = append(sections, memorySection{
+					Address: section.Addr,
+					Size:    section.Size,
+					Type:    memoryData,
+				})
+			} else if section.Type == elf.SHT_PROGBITS {
+				// .rodata
+				sections = append(sections, memorySection{
+					Address: section.Addr,
+					Size:    section.Size,
+					Type:    memoryROData,
+				})
+			}
+		}
+	} else if file, err := wasm.Parse(f); err == nil {
+		// File is in WebAssembly format.
+
+		// Put code at a very high address, so that it won't conflict with the
+		// data in the memory section.
+		const codeOffset = 0x8000_0000_0000_0000
+
+		// Read DWARF information. The error is intentionally ignored.
+		data, err := file.DWARF()
+		if data != nil {
+			addresses, err = readProgramSizeFromDWARF(data, codeOffset)
+			if err != nil {
+				// However, _do_ report an error here. Something must have gone
+				// wrong while trying to parse DWARF data.
+				return nil, err
+			}
+		}
+
+		var linearMemorySize uint64
+		for _, section := range file.Sections {
+			switch section := section.(type) {
+			case *wasm.SectionCode:
+				sections = append(sections, memorySection{
+					Address: codeOffset,
+					Size:    uint64(section.Size()),
+					Type:    memoryCode,
+				})
+			case *wasm.SectionMemory:
+				// This value is used when processing *wasm.SectionData (which
+				// always comes after *wasm.SectionMemory).
+				linearMemorySize = uint64(section.Entries[0].Limits.Initial) * 64 * 1024
+			case *wasm.SectionData:
+				// Data sections contain initial values for linear memory.
+				// First load the list of data sections, and sort them by
+				// address for easier processing.
+				var dataSections []memorySection
+				for _, entry := range section.Entries {
+					address, err := wasm.Eval(bytes.NewBuffer(entry.Offset))
+					if err != nil {
+						return nil, fmt.Errorf("could not parse data section address: %w", err)
+					}
+					dataSections = append(dataSections, memorySection{
+						Address: uint64(address[0].(int32)),
+						Size:    uint64(len(entry.Data)),
+						Type:    memoryData,
+					})
+				}
+				sort.Slice(dataSections, func(i, j int) bool {
+					return dataSections[i].Address < dataSections[j].Address
+				})
+
+				// And now add all data sections for linear memory.
+				// Parts that are in the slice of data sections are added as
+				// memoryData, and parts that are not are added as memoryBSS.
+				addr := uint64(0)
+				for _, section := range dataSections {
+					if addr < section.Address {
+						sections = append(sections, memorySection{
+							Address: addr,
+							Size:    section.Address - addr,
+							Type:    memoryBSS,
+						})
+					}
+					if addr > section.Address {
+						// This might be allowed, I'm not sure.
+						// It certainly doesn't make a lot of sense.
+						return nil, fmt.Errorf("overlapping data section")
+					}
+					// addr == section.Address
+					sections = append(sections, section)
+					addr = section.Address + section.Size
+				}
+				if addr < linearMemorySize {
+					sections = append(sections, memorySection{
+						Address: addr,
+						Size:    linearMemorySize - addr,
+						Type:    memoryBSS,
+					})
+				}
+			}
+		}
+	} else {
+		return nil, fmt.Errorf("could not parse file: %w", err)
 	}
 
-	sum := &packageSize{}
+	// Sort the slice of address chunks by address, so that we can iterate
+	// through it to calculate section sizes.
+	sort.Slice(addresses, func(i, j int) bool {
+		if addresses[i].Address == addresses[j].Address {
+			// Very rarely, there might be duplicate addresses.
+			// If that happens, sort the largest chunks first.
+			return addresses[i].Length > addresses[j].Length
+		}
+		return addresses[i].Address < addresses[j].Address
+	})
+
+	// Now finally determine the binary/RAM size usage per package by going
+	// through each allocated section.
+	sizes := make(map[string]packageSize)
+	for _, section := range sections {
+		switch section.Type {
+		case memoryCode:
+			readSection(section, addresses, func(path string, size uint64, isVariable bool) {
+				field := sizes[path]
+				if isVariable {
+					field.ROData += size
+				} else {
+					field.Code += size
+				}
+				sizes[path] = field
+			}, packagePathMap)
+		case memoryROData:
+			readSection(section, addresses, func(path string, size uint64, isVariable bool) {
+				field := sizes[path]
+				field.ROData += size
+				sizes[path] = field
+			}, packagePathMap)
+		case memoryData:
+			readSection(section, addresses, func(path string, size uint64, isVariable bool) {
+				field := sizes[path]
+				field.Data += size
+				sizes[path] = field
+			}, packagePathMap)
+		case memoryBSS:
+			readSection(section, addresses, func(path string, size uint64, isVariable bool) {
+				field := sizes[path]
+				field.BSS += size
+				sizes[path] = field
+			}, packagePathMap)
+		case memoryStack:
+			// We store the C stack as a pseudo-package.
+			sizes["C stack"] = packageSize{
+				BSS: section.Size,
+			}
+		}
+	}
+
+	// ...and summarize the results.
+	program := &programSize{
+		Packages: sizes,
+	}
 	for _, pkg := range sizes {
-		sum.Code += pkg.Code
-		sum.ROData += pkg.ROData
-		sum.Data += pkg.Data
-		sum.BSS += pkg.BSS
+		program.Code += pkg.Code
+		program.ROData += pkg.ROData
+		program.Data += pkg.Data
+		program.BSS += pkg.BSS
 	}
-
-	return &programSize{Packages: sizes, Code: sumCode, Data: sumData, BSS: sumBSS, Sum: sum}, nil
+	return program, nil
+}
+
+// readSection determines for each byte in this section to which package it
+// belongs. It reports this usage through the addSize callback.
+func readSection(section memorySection, addresses []addressLine, addSize func(string, uint64, bool), packagePathMap map[string]string) {
+	// The addr variable tracks at which address we are while going through this
+	// section. We start at the beginning.
+	addr := section.Address
+	sectionEnd := section.Address + section.Size
+	for _, line := range addresses {
+		if line.Address < section.Address || line.Address+line.Length >= sectionEnd {
+			// Check that this line is entirely within the section.
+			// Don't bother dealing with line entries that cross sections (that
+			// seems rather unlikely anyway).
+			continue
+		}
+		if addr < line.Address {
+			// There is a gap: there is a space between the current and the
+			// previous line entry.
+			addSize("(unknown)", line.Address-addr, false)
+			if sizesDebug {
+				fmt.Printf("%08x..%08x %4d: unknown (gap)\n", addr, line.Address, line.Address-addr)
+			}
+		}
+		if addr > line.Address+line.Length {
+			// The current line is already covered by a previous line entry.
+			// Simply skip it.
+			continue
+		}
+		// At this point, addr falls within the current line (probably at the
+		// start).
+		length := line.Length
+		if addr > line.Address {
+			// There is some overlap: the previous line entry already covered
+			// part of this line entry. So reduce the length to add to the
+			// remaining bit of the line entry.
+			length = line.Length - (addr - line.Address)
+		}
+		// Finally, mark this chunk of memory as used by the given package.
+		addSize(findPackagePath(line.File, packagePathMap), length, line.IsVariable)
+		addr = line.Address + line.Length
+	}
+	if addr < sectionEnd {
+		// There is a gap at the end of the section.
+		addSize("(unknown)", sectionEnd-addr, false)
+		if sizesDebug {
+			fmt.Printf("%08x..%08x %4d: unknown (end)\n", addr, sectionEnd, sectionEnd-addr)
+		}
+	}
+}
+
+// findPackagePath returns the Go package (or a pseudo package) for the given
+// path. It uses some heuristics, for example for some C libraries.
+func findPackagePath(path string, packagePathMap map[string]string) string {
+	// Check whether this path is part of one of the compiled packages.
+	packagePath, ok := packagePathMap[filepath.Dir(path)]
+	if !ok {
+		if strings.HasPrefix(path, filepath.Join(goenv.Get("TINYGOROOT"), "lib")) {
+			// Emit C libraries (in the lib subdirectory of TinyGo) as a single
+			// package, with a "C" prefix. For example: "C compiler-rt" for the
+			// compiler runtime library from LLVM.
+			packagePath = "C " + strings.Split(strings.TrimPrefix(path, filepath.Join(goenv.Get("TINYGOROOT"), "lib")), string(os.PathSeparator))[1]
+		} else if packageSymbolRegexp.MatchString(path) {
+			// Parse symbol names like main$alloc or runtime$string.
+			packagePath = path[:strings.LastIndex(path, "$")]
+		} else if reflectDataRegexp.MatchString(path) {
+			// Parse symbol names like reflect.structTypesSidetable.
+			packagePath = "Go reflect data"
+		} else if path == "<Go interface assert>" {
+			// Interface type assert, generated by the interface lowering pass.
+			packagePath = "Go interface assert"
+		} else if path == "<Go interface method>" {
+			// Interface method wrapper (switch over all concrete types),
+			// generated by the interface lowering pass.
+			packagePath = "Go interface method"
+		} else if path == "<stdin>" {
+			// This can happen when the source code (in Go) doesn't have a
+			// source file and uses "-" as the location. Somewhere this is
+			// converted to "<stdin>".
+			// Convert this back to the "-" string. Eventually, this should be
+			// fixed in the compiler.
+			packagePath = "-"
+		} else {
+			// This is some other path. Not sure what it is, so just emit its directory.
+			packagePath = filepath.Dir(path) // fallback
+		}
+	}
+	return packagePath
 }

builder/tools.go

@@ -9,8 +9,8 @@ import (
 )
 
 // runCCompiler invokes a C compiler with the given arguments.
-func runCCompiler(command string, flags ...string) error {
-	if hasBuiltinTools && command == "clang" {
+func runCCompiler(flags ...string) error {
+	if hasBuiltinTools {
 		// Compile this with the internal Clang compiler.
 		headerPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
 		if headerPath == "" {
@@ -23,17 +23,8 @@ func runCCompiler(command string, flags ...string) error {
 		return cmd.Run()
 	}
 
-	// Running some other compiler. Maybe it has been defined in the
-	// commands map (unlikely).
-	if cmdNames, ok := commands[command]; ok {
-		return execCommand(cmdNames, flags...)
-	}
-
-	// Alternatively, run the compiler directly.
-	cmd := exec.Command(command, flags...)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
+	// Compile this with an external invocation of the Clang compiler.
+	return execCommand("clang", flags...)
 }
 
 // link invokes a linker with the given name and flags.
@@ -47,8 +38,8 @@ func link(linker string, flags ...string) error {
 	}
 
 	// Fall back to external command.
-	if cmdNames, ok := commands[linker]; ok {
-		return execCommand(cmdNames, flags...)
+	if _, ok := commands[linker]; ok {
+		return execCommand(linker, flags...)
 	}
 
 	cmd := exec.Command(linker, flags...)

builder/uf2.go

@@ -141,11 +141,13 @@ func split(input []byte, limit int) [][]byte {
 	var block []byte
 	output := make([][]byte, 0, len(input)/limit+1)
 	for len(input) >= limit {
+		// add all blocks
 		block, input = input[:limit], input[limit:]
 		output = append(output, block)
 	}
 	if len(input) > 0 {
-		output = append(output, input[:len(input)])
+		// add remaining block (that isn't full sized)
+		output = append(output, input)
 	}
 	return output
 }

cgo/cgo.go

@@ -25,12 +25,19 @@ import (
 	"golang.org/x/tools/go/ast/astutil"
 )
 
+// Version of the cgo package. It must be incremented whenever the cgo package
+// is changed in a way that affects the output so that cached package builds
+// will be invalidated.
+// This version is independent of the TinyGo version number.
+const Version = 1 // last change: run libclang once per Go file
+
 // cgoPackage holds all CGo-related information of a package.
 type cgoPackage struct {
 	generated       *ast.File
 	generatedPos    token.Pos
 	errors          []error
-	dir             string
+	currentDir      string // current working directory
+	packageDir      string // full path to the package to process
 	fset            *token.FileSet
 	tokenFiles      map[string]*token.File
 	missingSymbols  map[string]struct{}
@@ -41,7 +48,9 @@ type cgoPackage struct {
 	elaboratedTypes map[string]*elaboratedTypeInfo
 	enums           map[string]enumInfo
 	anonStructNum   int
-	ldflags         []string
+	cflags          []string // CFlags from #cgo lines
+	ldflags         []string // LDFlags from #cgo lines
+	visitedFiles    map[string][]byte
 }
 
 // constantInfo stores some information about a CGo constant found by libclang
@@ -54,9 +63,10 @@ type constantInfo struct {
 // functionInfo stores some information about a CGo function found by libclang
 // and declared in the AST.
 type functionInfo struct {
-	args    []paramInfo
-	results *ast.FieldList
-	pos     token.Pos
+	args     []paramInfo
+	results  *ast.FieldList
+	pos      token.Pos
+	variadic bool
 }
 
 // paramInfo is a parameter of a CGo function (see functionInfo).
@@ -121,17 +131,17 @@ var cgoAliases = map[string]string{
 // builtinAliases are handled specially because they only exist on the Go side
 // of CGo, not on the CGo side (they're prefixed with "_Cgo_" there).
 var builtinAliases = map[string]struct{}{
-	"char":      struct{}{},
-	"schar":     struct{}{},
-	"uchar":     struct{}{},
-	"short":     struct{}{},
-	"ushort":    struct{}{},
-	"int":       struct{}{},
-	"uint":      struct{}{},
-	"long":      struct{}{},
-	"ulong":     struct{}{},
-	"longlong":  struct{}{},
-	"ulonglong": struct{}{},
+	"char":      {},
+	"schar":     {},
+	"uchar":     {},
+	"short":     {},
+	"ushort":    {},
+	"int":       {},
+	"uint":      {},
+	"long":      {},
+	"ulong":     {},
+	"longlong":  {},
+	"ulonglong": {},
 }
 
 // cgoTypes lists some C types with ambiguous sizes that must be retrieved
@@ -155,11 +165,13 @@ typedef unsigned long long  _Cgo_ulonglong;
 // Process extracts `import "C"` statements from the AST, parses the comment
 // with libclang, and modifies the AST to use this information. It returns a
 // newly created *ast.File that should be added to the list of to-be-parsed
-// files. If there is one or more error, it returns these in the []error slice
-// but still modifies the AST.
-func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []string, []error) {
+// files, the CGo header snippets that should be compiled (for inline
+// functions), the CFLAGS and LDFLAGS found in #cgo lines, and a map of file
+// hashes of the accessed C header files. If there is one or more error, it
+// returns these in the []error slice but still modifies the AST.
+func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []string, []string, []string, map[string][]byte, []error) {
 	p := &cgoPackage{
-		dir:             dir,
+		currentDir:      dir,
 		fset:            fset,
 		tokenFiles:      map[string]*token.File{},
 		missingSymbols:  map[string]struct{}{},
@@ -169,13 +181,9 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 		typedefs:        map[string]*typedefInfo{},
 		elaboratedTypes: map[string]*elaboratedTypeInfo{},
 		enums:           map[string]enumInfo{},
+		visitedFiles:    map[string][]byte{},
 	}
 
-	// Disable _FORTIFY_SOURCE as it causes problems on macOS.
-	// Note that it is only disabled for memcpy (etc) calls made from Go, which
-	// have better alternatives anyway.
-	cflags = append(cflags, "-D_FORTIFY_SOURCE=0")
-
 	// Add a new location for the following file.
 	generatedTokenPos := p.fset.AddFile(dir+"/!cgo.go", -1, 0)
 	generatedTokenPos.SetLines([]int{0})
@@ -184,14 +192,14 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	// Find the absolute path for this package.
 	packagePath, err := filepath.Abs(fset.File(files[0].Pos()).Name())
 	if err != nil {
-		return nil, nil, []error{
+		return nil, nil, nil, nil, nil, []error{
 			scanner.Error{
 				Pos: fset.Position(files[0].Pos()),
 				Msg: "cgo: cannot find absolute path: " + err.Error(), // TODO: wrap this error
 			},
 		}
 	}
-	packagePath = filepath.Dir(packagePath)
+	p.packageDir = filepath.Dir(packagePath)
 
 	// Construct a new in-memory AST for CGo declarations of this package.
 	unsafeImport := &ast.ImportSpec{
@@ -224,7 +232,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 				Specs: []ast.Spec{
 					&ast.ValueSpec{
 						Names: []*ast.Ident{
-							&ast.Ident{
+							{
 								Name: "_",
 								Obj: &ast.Object{
 									Kind: ast.Var,
@@ -255,9 +263,10 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 		p.missingSymbols["_Cgo_"+name] = struct{}{}
 	}
 
-	// Find `import "C"` statements in the file.
-	var statements []*ast.GenDecl
-	for _, f := range files {
+	// Find `import "C"` C fragments in the file.
+	cgoHeaders := make([]string, len(files)) // combined CGo header fragment for each file
+	for i, f := range files {
+		var cgoHeader string
 		for i := 0; i < len(f.Decls); i++ {
 			decl := f.Decls[i]
 			genDecl, ok := decl.(*ast.GenDecl)
@@ -281,117 +290,52 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 				continue
 			}
 
-			// Found a CGo statement.
-			statements = append(statements, genDecl)
-
 			// Remove this import declaration.
 			f.Decls = append(f.Decls[:i], f.Decls[i+1:]...)
 			i--
-		}
 
-		// Print the AST, for debugging.
-		//ast.Print(fset, f)
-	}
-
-	// Find all #cgo lines.
-	for _, genDecl := range statements {
-		if genDecl.Doc == nil {
-			continue
-		}
-		for _, comment := range genDecl.Doc.List {
-			for {
-				// Extract the #cgo line, and replace it with spaces.
-				// Replacing with spaces makes sure that error locations are
-				// still correct, while not interfering with parsing in any way.
-				lineStart := strings.Index(comment.Text, "#cgo ")
-				if lineStart < 0 {
-					break
-				}
-				lineLen := strings.IndexByte(comment.Text[lineStart:], '\n')
-				if lineLen < 0 {
-					lineLen = len(comment.Text) - lineStart
-				}
-				lineEnd := lineStart + lineLen
-				line := comment.Text[lineStart:lineEnd]
-				spaces := make([]byte, len(line))
-				for i := range spaces {
-					spaces[i] = ' '
-				}
-				lenBefore := len(comment.Text)
-				comment.Text = comment.Text[:lineStart] + string(spaces) + comment.Text[lineEnd:]
-				if len(comment.Text) != lenBefore {
-					println(lenBefore, len(comment.Text))
-					panic("length of preamble changed!")
-				}
-
-				// Get the text before the colon in the #cgo directive.
-				colon := strings.IndexByte(line, ':')
-				if colon < 0 {
-					p.addErrorAfter(comment.Slash, comment.Text[:lineStart], "missing colon in #cgo line")
-					continue
-				}
-
-				// Extract the fields before the colon. These fields are a list
-				// of build tags and the C environment variable.
-				fields := strings.Fields(line[4:colon])
-				if len(fields) == 0 {
-					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon-1], "invalid #cgo line")
-					continue
-				}
-
-				if len(fields) > 1 {
-					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+5], "not implemented: build constraints in #cgo line")
-					continue
-				}
-
-				name := fields[len(fields)-1]
-				value := line[colon+1:]
-				switch name {
-				case "CFLAGS":
-					flags, err := shlex.Split(value)
-					if err != nil {
-						// TODO: find the exact location where the error happened.
-						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
-						continue
-					}
-					if err := checkCompilerFlags(name, flags); err != nil {
-						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
-						continue
-					}
-					makePathsAbsolute(flags, packagePath)
-					cflags = append(cflags, flags...)
-				case "LDFLAGS":
-					flags, err := shlex.Split(value)
-					if err != nil {
-						// TODO: find the exact location where the error happened.
-						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
-						continue
-					}
-					if err := checkLinkerFlags(name, flags); err != nil {
-						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
-						continue
-					}
-					makePathsAbsolute(flags, packagePath)
-					p.ldflags = append(p.ldflags, flags...)
-				default:
-					startPos := strings.LastIndex(line[4:colon], name) + 4
-					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+startPos], "invalid #cgo line: "+name)
-					continue
-				}
+			if genDecl.Doc == nil {
+				continue
 			}
+
+			// Iterate through all parts of the CGo header. Note that every //
+			// line is a new comment.
+			position := fset.Position(genDecl.Doc.Pos())
+			fragment := fmt.Sprintf("# %d %#v\n", position.Line, position.Filename)
+			for _, comment := range genDecl.Doc.List {
+				// Find all #cgo lines, extract and use their contents, and
+				// replace the lines with spaces (to preserve locations).
+				c := p.parseCGoPreprocessorLines(comment.Text, comment.Slash)
+
+				// Change the comment (which is still in Go syntax, with // and
+				// /* */ ) to a regular string by replacing the start/end
+				// markers of comments with spaces.
+				// It is similar to the Text() method but differs in that it
+				// doesn't strip anything and tries to keep all offsets correct
+				// by adding spaces and newlines where necessary.
+				if c[1] == '/' { /* comment */
+					c = "  " + c[2:]
+				} else { // comment
+					c = "  " + c[2:len(c)-2]
+				}
+				fragment += c + "\n"
+			}
+			cgoHeader += fragment
 		}
+
+		cgoHeaders[i] = cgoHeader
 	}
 
-	// Process all CGo imports.
-	for _, genDecl := range statements {
-		cgoComment := genDecl.Doc.Text()
+	// Define CFlags that will be used while parsing the package.
+	// Disable _FORTIFY_SOURCE as it causes problems on macOS.
+	// Note that it is only disabled for memcpy (etc) calls made from Go, which
+	// have better alternatives anyway.
+	cflagsForCGo := append([]string{"-D_FORTIFY_SOURCE=0"}, cflags...)
+	cflagsForCGo = append(cflagsForCGo, p.cflags...)
 
-		pos := genDecl.Pos()
-		if genDecl.Doc != nil {
-			pos = genDecl.Doc.Pos()
-		}
-		position := fset.PositionFor(pos, true)
-		p.parseFragment(cgoComment+cgoTypes, cflags, position.Filename, position.Line)
+	// Process CGo imports for each file.
+	for i, f := range files {
+		p.parseFragment(cgoHeaders[i]+cgoTypes, cflagsForCGo, filepath.Base(fset.File(f.Pos()).Name()))
 	}
 
 	// Declare functions found by libclang.
@@ -426,18 +370,18 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	// Print the newly generated in-memory AST, for debugging.
 	//ast.Print(fset, p.generated)
 
-	return p.generated, p.ldflags, p.errors
+	return p.generated, cgoHeaders, p.cflags, p.ldflags, p.visitedFiles, p.errors
 }
 
 // makePathsAbsolute converts some common path compiler flags (-I, -L) from
 // relative flags into absolute flags, if they are relative. This is necessary
 // because the C compiler is usually not invoked from the package path.
-func makePathsAbsolute(args []string, packagePath string) {
+func (p *cgoPackage) makePathsAbsolute(args []string) {
 	nextIsPath := false
 	for i, arg := range args {
 		if nextIsPath {
 			if !filepath.IsAbs(arg) {
-				args[i] = filepath.Join(packagePath, arg)
+				args[i] = filepath.Join(p.packageDir, arg)
 			}
 		}
 		if arg == "-I" || arg == "-L" {
@@ -447,12 +391,95 @@ func makePathsAbsolute(args []string, packagePath string) {
 		if strings.HasPrefix(arg, "-I") || strings.HasPrefix(arg, "-L") {
 			path := arg[2:]
 			if !filepath.IsAbs(path) {
-				args[i] = arg[:2] + filepath.Join(packagePath, path)
+				args[i] = arg[:2] + filepath.Join(p.packageDir, path)
 			}
 		}
 	}
 }
 
+// parseCGoPreprocessorLines reads #cgo pseudo-preprocessor lines in the source
+// text (import "C" fragment), stores their information such as CFLAGS, and
+// returns the same text but with those #cgo lines replaced by spaces (to keep
+// position offsets the same).
+func (p *cgoPackage) parseCGoPreprocessorLines(text string, pos token.Pos) string {
+	for {
+		// Extract the #cgo line, and replace it with spaces.
+		// Replacing with spaces makes sure that error locations are
+		// still correct, while not interfering with parsing in any way.
+		lineStart := strings.Index(text, "#cgo ")
+		if lineStart < 0 {
+			break
+		}
+		lineLen := strings.IndexByte(text[lineStart:], '\n')
+		if lineLen < 0 {
+			lineLen = len(text) - lineStart
+		}
+		lineEnd := lineStart + lineLen
+		line := text[lineStart:lineEnd]
+		spaces := make([]byte, len(line))
+		for i := range spaces {
+			spaces[i] = ' '
+		}
+		text = text[:lineStart] + string(spaces) + text[lineEnd:]
+
+		// Get the text before the colon in the #cgo directive.
+		colon := strings.IndexByte(line, ':')
+		if colon < 0 {
+			p.addErrorAfter(pos, text[:lineStart], "missing colon in #cgo line")
+			continue
+		}
+
+		// Extract the fields before the colon. These fields are a list
+		// of build tags and the C environment variable.
+		fields := strings.Fields(line[4:colon])
+		if len(fields) == 0 {
+			p.addErrorAfter(pos, text[:lineStart+colon-1], "invalid #cgo line")
+			continue
+		}
+
+		if len(fields) > 1 {
+			p.addErrorAfter(pos, text[:lineStart+5], "not implemented: build constraints in #cgo line")
+			continue
+		}
+
+		name := fields[len(fields)-1]
+		value := line[colon+1:]
+		switch name {
+		case "CFLAGS":
+			flags, err := shlex.Split(value)
+			if err != nil {
+				// TODO: find the exact location where the error happened.
+				p.addErrorAfter(pos, text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
+				continue
+			}
+			if err := checkCompilerFlags(name, flags); err != nil {
+				p.addErrorAfter(pos, text[:lineStart+colon+1], err.Error())
+				continue
+			}
+			p.makePathsAbsolute(flags)
+			p.cflags = append(p.cflags, flags...)
+		case "LDFLAGS":
+			flags, err := shlex.Split(value)
+			if err != nil {
+				// TODO: find the exact location where the error happened.
+				p.addErrorAfter(pos, text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
+				continue
+			}
+			if err := checkLinkerFlags(name, flags); err != nil {
+				p.addErrorAfter(pos, text[:lineStart+colon+1], err.Error())
+				continue
+			}
+			p.makePathsAbsolute(flags)
+			p.ldflags = append(p.ldflags, flags...)
+		default:
+			startPos := strings.LastIndex(line[4:colon], name) + 4
+			p.addErrorAfter(pos, text[:lineStart+startPos], "invalid #cgo line: "+name)
+			continue
+		}
+	}
+	return text
+}
+
 // addFuncDecls adds the C function declarations found by libclang in the
 // comment above the `import "C"` statement.
 func (p *cgoPackage) addFuncDecls() {
@@ -484,11 +511,21 @@ func (p *cgoPackage) addFuncDecls() {
 				Results: fn.results,
 			},
 		}
+		if fn.variadic {
+			decl.Doc = &ast.CommentGroup{
+				List: []*ast.Comment{
+					{
+						Slash: fn.pos,
+						Text:  "//go:variadic",
+					},
+				},
+			}
+		}
 		obj.Decl = decl
 		for i, arg := range fn.args {
 			args[i] = &ast.Field{
 				Names: []*ast.Ident{
-					&ast.Ident{
+					{
 						NamePos: fn.pos,
 						Name:    arg.name,
 						Obj: &ast.Object{
@@ -536,7 +573,7 @@ func (p *cgoPackage) addFuncPtrDecls() {
 			Name: "C." + name + "$funcaddr",
 		}
 		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{&ast.Ident{
+			Names: []*ast.Ident{{
 				NamePos: fn.pos,
 				Name:    "C." + name + "$funcaddr",
 				Obj:     obj,
@@ -586,7 +623,7 @@ func (p *cgoPackage) addConstDecls() {
 			Name: "C." + name,
 		}
 		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{&ast.Ident{
+			Names: []*ast.Ident{{
 				NamePos: constVal.pos,
 				Name:    "C." + name,
 				Obj:     obj,
@@ -627,7 +664,7 @@ func (p *cgoPackage) addVarDecls() {
 			Name: "C." + name,
 		}
 		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{&ast.Ident{
+			Names: []*ast.Ident{{
 				NamePos: global.pos,
 				Name:    "C." + name,
 				Obj:     obj,
@@ -828,9 +865,9 @@ func (p *cgoPackage) makeUnionField(typ *elaboratedTypeInfo) *ast.StructType {
 		Struct: typ.typeExpr.Struct,
 		Fields: &ast.FieldList{
 			Opening: typ.typeExpr.Fields.Opening,
-			List: []*ast.Field{&ast.Field{
+			List: []*ast.Field{{
 				Names: []*ast.Ident{
-					&ast.Ident{
+					{
 						NamePos: typ.typeExpr.Fields.Opening,
 						Name:    "$union",
 					},
@@ -911,9 +948,9 @@ func (p *cgoPackage) createUnionAccessor(field *ast.Field, typeName string) {
 		Recv: &ast.FieldList{
 			Opening: pos,
 			List: []*ast.Field{
-				&ast.Field{
+				{
 					Names: []*ast.Ident{
-						&ast.Ident{
+						{
 							NamePos: pos,
 							Name:    "union",
 						},
@@ -942,7 +979,7 @@ func (p *cgoPackage) createUnionAccessor(field *ast.Field, typeName string) {
 			},
 			Results: &ast.FieldList{
 				List: []*ast.Field{
-					&ast.Field{
+					{
 						Type: &ast.StarExpr{
 							Star: pos,
 							X:    field.Type,
@@ -1021,9 +1058,9 @@ func (p *cgoPackage) createBitfieldGetter(bitfield bitfieldInfo, typeName string
 		Recv: &ast.FieldList{
 			Opening: bitfield.pos,
 			List: []*ast.Field{
-				&ast.Field{
+				{
 					Names: []*ast.Ident{
-						&ast.Ident{
+						{
 							NamePos: bitfield.pos,
 							Name:    "s",
 							Obj: &ast.Object{
@@ -1057,7 +1094,7 @@ func (p *cgoPackage) createBitfieldGetter(bitfield bitfieldInfo, typeName string
 			},
 			Results: &ast.FieldList{
 				List: []*ast.Field{
-					&ast.Field{
+					{
 						Type: bitfield.field.Type,
 					},
 				},
@@ -1174,9 +1211,9 @@ func (p *cgoPackage) createBitfieldSetter(bitfield bitfieldInfo, typeName string
 		Recv: &ast.FieldList{
 			Opening: bitfield.pos,
 			List: []*ast.Field{
-				&ast.Field{
+				{
 					Names: []*ast.Ident{
-						&ast.Ident{
+						{
 							NamePos: bitfield.pos,
 							Name:    "s",
 							Obj: &ast.Object{
@@ -1207,9 +1244,9 @@ func (p *cgoPackage) createBitfieldSetter(bitfield bitfieldInfo, typeName string
 			Params: &ast.FieldList{
 				Opening: bitfield.pos,
 				List: []*ast.Field{
-					&ast.Field{
+					{
 						Names: []*ast.Ident{
-							&ast.Ident{
+							{
 								NamePos: bitfield.pos,
 								Name:    "value",
 								Obj:     nil,

cgo/cgo_test.go

@@ -5,13 +5,13 @@ import (
 	"flag"
 	"fmt"
 	"go/ast"
+	"go/build"
 	"go/format"
 	"go/parser"
 	"go/token"
 	"go/types"
 	"io/ioutil"
 	"path/filepath"
-	"regexp"
 	"runtime"
 	"strings"
 	"testing"
@@ -23,24 +23,30 @@ var flagUpdate = flag.Bool("update", false, "Update images based on test output.
 // normalizeResult normalizes Go source code that comes out of tests across
 // platforms and Go versions.
 func normalizeResult(result string) string {
-	actual := strings.Replace(result, "\r\n", "\n", -1)
-
-	// Make sure all functions are wrapped, even those that would otherwise be
-	// single-line functions. This is necessary because Go 1.14 changed the way
-	// such functions are wrapped and it's important to have consistent test
-	// results.
-	re := regexp.MustCompile(`func \((.+)\)( .*?) +{ (.+) }`)
-	actual = re.ReplaceAllString(actual, "func ($1)$2 {\n\t$3\n}")
-
+	actual := strings.ReplaceAll(result, "\r\n", "\n")
 	return actual
 }
 
 func TestCGo(t *testing.T) {
-	var cflags = []string{"--target=armv6m-none-eabi"}
+	var cflags = []string{"--target=armv6m-unknown-unknown-eabi"}
 
 	for _, name := range []string{"basic", "errors", "types", "flags", "const"} {
 		name := name // avoid a race condition
 		t.Run(name, func(t *testing.T) {
+			// Skip tests that require specific Go version.
+			if name == "errors" {
+				ok := false
+				for _, version := range build.Default.ReleaseTags {
+					if version == "go1.16" {
+						ok = true
+						break
+					}
+				}
+				if !ok {
+					t.Skip("Results for errors test are only valid for Go 1.16+")
+				}
+			}
+
 			// Read the AST in memory.
 			path := filepath.Join("testdata", name+".go")
 			fset := token.NewFileSet()
@@ -50,7 +56,7 @@ func TestCGo(t *testing.T) {
 			}
 
 			// Process the AST with CGo.
-			cgoAST, _, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)
+			cgoAST, _, _, _, _, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)
 
 			// Check the AST for type errors.
 			var typecheckErrors []error
@@ -90,7 +96,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Errorf("could not write out CGo AST: %v", err)
 			}
-			actual := normalizeResult(string(buf.Bytes()))
+			actual := normalizeResult(buf.String())
 
 			// Read the file with the expected output, to compare against.
 			outfile := filepath.Join("testdata", name+".out.go")
@@ -98,7 +104,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Fatalf("could not read expected output: %v", err)
 			}
-			expected := strings.Replace(string(expectedBytes), "\r\n", "\n", -1)
+			expected := strings.ReplaceAll(string(expectedBytes), "\r\n", "\n")
 
 			// Check whether the output is as expected.
 			if expected != actual {
@@ -139,7 +145,7 @@ func formatDiagnostic(err error) string {
 	msg := err.Error()
 	if runtime.GOOS == "windows" {
 		// Fix Windows path slashes.
-		msg = strings.Replace(msg, "testdata\\", "testdata/", -1)
+		msg = strings.ReplaceAll(msg, "testdata\\", "testdata/")
 	}
 	return "//     " + msg + "\n"
 }

cgo/const.go

@@ -11,105 +11,184 @@ import (
 	"strings"
 )
 
+var (
+	prefixParseFns map[token.Token]func(*tokenizer) (ast.Expr, *scanner.Error)
+	precedences    = map[token.Token]int{
+		token.ADD: precedenceAdd,
+		token.SUB: precedenceAdd,
+		token.MUL: precedenceMul,
+		token.QUO: precedenceMul,
+		token.REM: precedenceMul,
+	}
+)
+
+const (
+	precedenceLowest = iota + 1
+	precedenceAdd
+	precedenceMul
+	precedencePrefix
+)
+
+func init() {
+	// This must be done in an init function to avoid an initialization order
+	// failure.
+	prefixParseFns = map[token.Token]func(*tokenizer) (ast.Expr, *scanner.Error){
+		token.IDENT:  parseIdent,
+		token.INT:    parseBasicLit,
+		token.FLOAT:  parseBasicLit,
+		token.STRING: parseBasicLit,
+		token.CHAR:   parseBasicLit,
+		token.LPAREN: parseParenExpr,
+		token.SUB:    parseUnaryExpr,
+	}
+}
+
 // parseConst parses the given string as a C constant.
 func parseConst(pos token.Pos, fset *token.FileSet, value string) (ast.Expr, *scanner.Error) {
 	t := newTokenizer(pos, fset, value)
-	expr, err := parseConstExpr(t)
-	if t.token != token.EOF {
+	expr, err := parseConstExpr(t, precedenceLowest)
+	t.Next()
+	if t.curToken != token.EOF {
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.pos),
-			Msg: "unexpected token " + t.token.String(),
+			Pos: t.fset.Position(t.curPos),
+			Msg: "unexpected token " + t.curToken.String() + ", expected end of expression",
 		}
 	}
 	return expr, err
 }
 
 // parseConstExpr parses a stream of C tokens to a Go expression.
-func parseConstExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
-	switch t.token {
-	case token.LPAREN:
-		lparen := t.pos
-		t.Next()
-		x, err := parseConstExpr(t)
-		if err != nil {
-			return nil, err
-		}
-		if t.token != token.RPAREN {
-			return nil, unexpectedToken(t, token.RPAREN)
-		}
-		expr := &ast.ParenExpr{
-			Lparen: lparen,
-			X:      x,
-			Rparen: t.pos,
-		}
-		t.Next()
-		return expr, nil
-	case token.INT, token.FLOAT, token.STRING, token.CHAR:
-		expr := &ast.BasicLit{
-			ValuePos: t.pos,
-			Kind:     t.token,
-			Value:    t.value,
-		}
-		t.Next()
-		return expr, nil
-	case token.IDENT:
-		expr := &ast.Ident{
-			NamePos: t.pos,
-			Name:    "C." + t.value,
-		}
-		t.Next()
-		return expr, nil
-	case token.EOF:
+func parseConstExpr(t *tokenizer, precedence int) (ast.Expr, *scanner.Error) {
+	if t.curToken == token.EOF {
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.pos),
+			Pos: t.fset.Position(t.curPos),
 			Msg: "empty constant",
 		}
-	default:
+	}
+	prefix := prefixParseFns[t.curToken]
+	if prefix == nil {
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.pos),
-			Msg: fmt.Sprintf("unexpected token %s", t.token),
+			Pos: t.fset.Position(t.curPos),
+			Msg: fmt.Sprintf("unexpected token %s", t.curToken),
 		}
 	}
+	leftExpr, err := prefix(t)
+
+	for t.peekToken != token.EOF && precedence < precedences[t.peekToken] {
+		switch t.peekToken {
+		case token.ADD, token.SUB, token.MUL, token.QUO, token.REM:
+			t.Next()
+			leftExpr, err = parseBinaryExpr(t, leftExpr)
+		}
+	}
+
+	return leftExpr, err
+}
+
+func parseIdent(t *tokenizer) (ast.Expr, *scanner.Error) {
+	return &ast.Ident{
+		NamePos: t.curPos,
+		Name:    "C." + t.curValue,
+	}, nil
+}
+
+func parseBasicLit(t *tokenizer) (ast.Expr, *scanner.Error) {
+	return &ast.BasicLit{
+		ValuePos: t.curPos,
+		Kind:     t.curToken,
+		Value:    t.curValue,
+	}, nil
+}
+
+func parseParenExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
+	lparen := t.curPos
+	t.Next()
+	x, err := parseConstExpr(t, precedenceLowest)
+	if err != nil {
+		return nil, err
+	}
+	t.Next()
+	if t.curToken != token.RPAREN {
+		return nil, unexpectedToken(t, token.RPAREN)
+	}
+	expr := &ast.ParenExpr{
+		Lparen: lparen,
+		X:      x,
+		Rparen: t.curPos,
+	}
+	return expr, nil
+}
+
+func parseBinaryExpr(t *tokenizer, left ast.Expr) (ast.Expr, *scanner.Error) {
+	expression := &ast.BinaryExpr{
+		X:     left,
+		Op:    t.curToken,
+		OpPos: t.curPos,
+	}
+	precedence := precedences[t.curToken]
+	t.Next()
+	right, err := parseConstExpr(t, precedence)
+	expression.Y = right
+	return expression, err
+}
+
+func parseUnaryExpr(t *tokenizer) (ast.Expr, *scanner.Error) {
+	expression := &ast.UnaryExpr{
+		OpPos: t.curPos,
+		Op:    t.curToken,
+	}
+	t.Next()
+	x, err := parseConstExpr(t, precedencePrefix)
+	expression.X = x
+	return expression, err
 }
 
 // unexpectedToken returns an error of the form "unexpected token FOO, expected
 // BAR".
 func unexpectedToken(t *tokenizer, expected token.Token) *scanner.Error {
 	return &scanner.Error{
-		Pos: t.fset.Position(t.pos),
-		Msg: fmt.Sprintf("unexpected token %s, expected %s", t.token, expected),
+		Pos: t.fset.Position(t.curPos),
+		Msg: fmt.Sprintf("unexpected token %s, expected %s", t.curToken, expected),
 	}
 }
 
 // tokenizer reads C source code and converts it to Go tokens.
 type tokenizer struct {
-	pos   token.Pos
-	fset  *token.FileSet
-	token token.Token
-	value string
-	buf   string
+	curPos, peekPos     token.Pos
+	fset                *token.FileSet
+	curToken, peekToken token.Token
+	curValue, peekValue string
+	buf                 string
 }
 
 // newTokenizer initializes a new tokenizer, positioned at the first token in
 // the string.
 func newTokenizer(start token.Pos, fset *token.FileSet, buf string) *tokenizer {
 	t := &tokenizer{
-		pos:   start,
-		fset:  fset,
-		buf:   buf,
-		token: token.ILLEGAL,
+		peekPos:   start,
+		fset:      fset,
+		buf:       buf,
+		peekToken: token.ILLEGAL,
 	}
-	t.Next() // Parse the first token.
+	// Parse the first two tokens (cur and peek).
+	t.Next()
+	t.Next()
 	return t
 }
 
 // Next consumes the next token in the stream. There is no return value, read
 // the next token from the pos, token and value properties.
 func (t *tokenizer) Next() {
-	t.pos += token.Pos(len(t.value))
+	// The previous peek is now the current token.
+	t.curPos = t.peekPos
+	t.curToken = t.peekToken
+	t.curValue = t.peekValue
+
+	// Parse the next peek token.
+	t.peekPos += token.Pos(len(t.curValue))
 	for {
 		if len(t.buf) == 0 {
-			t.token = token.EOF
+			t.peekToken = token.EOF
 			return
 		}
 		c := t.buf[0]
@@ -118,17 +197,28 @@ func (t *tokenizer) Next() {
 			// Skip whitespace.
 			// Based on this source, not sure whether it represents C whitespace:
 			// https://en.cppreference.com/w/cpp/string/byte/isspace
-			t.pos++
+			t.peekPos++
 			t.buf = t.buf[1:]
-		case c == '(' || c == ')':
+		case c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/' || c == '%':
 			// Single-character tokens.
+			// TODO: ++ (increment) and -- (decrement) operators.
 			switch c {
 			case '(':
-				t.token = token.LPAREN
+				t.peekToken = token.LPAREN
 			case ')':
-				t.token = token.RPAREN
+				t.peekToken = token.RPAREN
+			case '+':
+				t.peekToken = token.ADD
+			case '-':
+				t.peekToken = token.SUB
+			case '*':
+				t.peekToken = token.MUL
+			case '/':
+				t.peekToken = token.QUO
+			case '%':
+				t.peekToken = token.REM
 			}
-			t.value = t.buf[:1]
+			t.peekValue = t.buf[:1]
 			t.buf = t.buf[1:]
 			return
 		case c >= '0' && c <= '9':
@@ -146,17 +236,17 @@ func (t *tokenizer) Next() {
 					break
 				}
 			}
-			t.value = t.buf[:tokenLen]
+			t.peekValue = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			if hasDot {
 				// Integer constants are more complicated than this but this is
 				// a close approximation.
 				// https://en.cppreference.com/w/cpp/language/integer_literal
-				t.token = token.FLOAT
-				t.value = strings.TrimRight(t.value, "f")
+				t.peekToken = token.FLOAT
+				t.peekValue = strings.TrimRight(t.peekValue, "f")
 			} else {
-				t.token = token.INT
-				t.value = strings.TrimRight(t.value, "uUlL")
+				t.peekToken = token.INT
+				t.peekValue = strings.TrimRight(t.peekValue, "uUlL")
 			}
 			return
 		case c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c == '_':
@@ -170,9 +260,9 @@ func (t *tokenizer) Next() {
 					break
 				}
 			}
-			t.value = t.buf[:tokenLen]
+			t.peekValue = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
-			t.token = token.IDENT
+			t.peekToken = token.IDENT
 			return
 		case c == '"':
 			// String constant. Find the first '"' character that is not
@@ -188,8 +278,8 @@ func (t *tokenizer) Next() {
 					escape = c == '\\'
 				}
 			}
-			t.token = token.STRING
-			t.value = t.buf[:tokenLen]
+			t.peekToken = token.STRING
+			t.peekValue = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			return
 		case c == '\'':
@@ -206,12 +296,12 @@ func (t *tokenizer) Next() {
 					escape = c == '\\'
 				}
 			}
-			t.token = token.CHAR
-			t.value = t.buf[:tokenLen]
+			t.peekToken = token.CHAR
+			t.peekValue = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			return
 		default:
-			t.token = token.ILLEGAL
+			t.peekToken = token.ILLEGAL
 			return
 		}
 	}

cgo/const_test.go

@@ -18,7 +18,7 @@ func TestParseConst(t *testing.T) {
 		{`(5)`, `(5)`},
 		{`(((5)))`, `(5)`},
 		{`)`, `error: 1:1: unexpected token )`},
-		{`5)`, `error: 1:2: unexpected token )`},
+		{`5)`, `error: 1:2: unexpected token ), expected end of expression`},
 		{"  \t)", `error: 1:4: unexpected token )`},
 		{`5.8f`, `5.8`},
 		{`foo`, `C.foo`},
@@ -30,7 +30,24 @@ func TestParseConst(t *testing.T) {
 		{`'a'`, `'a'`},
 		{`0b10`, `0b10`},
 		{`0x1234_5678`, `0x1234_5678`},
-		{`5 5`, `error: 1:3: unexpected token INT`}, // test for a bugfix
+		{`5 5`, `error: 1:3: unexpected token INT, expected end of expression`}, // test for a bugfix
+		// Binary operators.
+		{`5+5`, `5 + 5`},
+		{`5-5`, `5 - 5`},
+		{`5*5`, `5 * 5`},
+		{`5/5`, `5 / 5`},
+		{`5%5`, `5 % 5`},
+		{`(5/5)`, `(5 / 5)`},
+		{`1 - 2`, `1 - 2`},
+		{`1 - 2 + 3`, `1 - 2 + 3`},
+		{`1 - 2 * 3`, `1 - 2*3`},
+		{`(1 - 2) * 3`, `(1 - 2) * 3`},
+		{`1 * 2 - 3`, `1*2 - 3`},
+		{`1 * (2 - 3)`, `1 * (2 - 3)`},
+		// Unary operators.
+		{`-5`, `-5`},
+		{`-5-2`, `-5 - 2`},
+		{`5 - - 2`, `5 - -2`},
 	} {
 		fset := token.NewFileSet()
 		startPos := fset.AddFile("", -1, 1000).Pos(0)

cgo/libclang.go

@@ -4,6 +4,7 @@ package cgo
 // modification. It does not touch the AST itself.
 
 import (
+	"crypto/sha512"
 	"fmt"
 	"go/ast"
 	"go/scanner"
@@ -15,7 +16,7 @@ import (
 )
 
 /*
-#include <clang-c/Index.h> // if this fails, install libclang-10-dev
+#include <clang-c/Index.h> // if this fails, install libclang-11-dev
 #include <stdlib.h>
 #include <stdint.h>
 
@@ -56,6 +57,7 @@ unsigned tinygo_clang_Cursor_isBitField(GoCXCursor c);
 int tinygo_clang_globals_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
 int tinygo_clang_struct_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
 int tinygo_clang_enum_visitor(GoCXCursor c, GoCXCursor parent, CXClientData client_data);
+void tinygo_clang_inclusion_visitor(CXFile included_file, CXSourceLocation *inclusion_stack, unsigned include_len, CXClientData client_data);
 */
 import "C"
 
@@ -70,17 +72,14 @@ var diagnosticSeverity = [...]string{
 	C.CXDiagnostic_Fatal:   "fatal",
 }
 
-func (p *cgoPackage) parseFragment(fragment string, cflags []string, posFilename string, posLine int) {
+func (p *cgoPackage) parseFragment(fragment string, cflags []string, filename string) {
 	index := C.clang_createIndex(0, 0)
 	defer C.clang_disposeIndex(index)
 
 	// pretend to be a .c file
-	filenameC := C.CString(posFilename + "!cgo.c")
+	filenameC := C.CString(filename + "!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))
 
@@ -114,6 +113,7 @@ func (p *cgoPackage) parseFragment(fragment string, cflags []string, posFilename
 	}
 	defer C.clang_disposeTranslationUnit(unit)
 
+	// Report parser and type errors.
 	if numDiagnostics := int(C.clang_getNumDiagnostics(unit)); numDiagnostics != 0 {
 		addDiagnostic := func(diagnostic C.CXDiagnostic) {
 			spelling := getString(C.clang_getDiagnosticSpelling(diagnostic))
@@ -134,10 +134,36 @@ func (p *cgoPackage) parseFragment(fragment string, cflags []string, posFilename
 		}
 	}
 
+	// Extract information required by CGo.
 	ref := storedRefs.Put(p)
 	defer storedRefs.Remove(ref)
 	cursor := C.tinygo_clang_getTranslationUnitCursor(unit)
 	C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_globals_visitor), C.CXClientData(ref))
+
+	// Determine files read during CGo processing, for caching.
+	inclusionCallback := func(includedFile C.CXFile) {
+		// Get full file path.
+		path := getString(C.clang_getFileName(includedFile))
+
+		// Get contents of file (that should be in-memory).
+		size := C.size_t(0)
+		rawData := C.clang_getFileContents(unit, includedFile, &size)
+		if rawData == nil {
+			// Sanity check. This should (hopefully) never trigger.
+			panic("libclang: file contents was not loaded")
+		}
+		data := (*[1 << 24]byte)(unsafe.Pointer(rawData))[:size]
+
+		// Hash the contents if it isn't hashed yet.
+		if _, ok := p.visitedFiles[path]; !ok {
+			// already stored
+			sum := sha512.Sum512_224(data)
+			p.visitedFiles[path] = sum[:]
+		}
+	}
+	inclusionCallbackRef := storedRefs.Put(inclusionCallback)
+	defer storedRefs.Remove(inclusionCallbackRef)
+	C.clang_getInclusions(unit, C.CXInclusionVisitor(C.tinygo_clang_inclusion_visitor), C.CXClientData(inclusionCallbackRef))
 }
 
 //export tinygo_clang_globals_visitor
@@ -152,12 +178,10 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 			return C.CXChildVisit_Continue
 		}
 		cursorType := C.tinygo_clang_getCursorType(c)
-		if C.clang_isFunctionTypeVariadic(cursorType) != 0 {
-			return C.CXChildVisit_Continue // not supported
-		}
 		numArgs := int(C.tinygo_clang_Cursor_getNumArguments(c))
 		fn := &functionInfo{
-			pos: pos,
+			pos:      pos,
+			variadic: C.clang_isFunctionTypeVariadic(cursorType) != 0,
 		}
 		p.functions[name] = fn
 		for i := 0; i < numArgs; i++ {
@@ -169,14 +193,14 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 			}
 			fn.args = append(fn.args, paramInfo{
 				name:     argName,
-				typeExpr: p.makeASTType(argType, pos),
+				typeExpr: p.makeDecayingASTType(argType, pos),
 			})
 		}
 		resultType := C.tinygo_clang_getCursorResultType(c)
 		if resultType.kind != C.CXType_Void {
 			fn.results = &ast.FieldList{
 				List: []*ast.Field{
-					&ast.Field{
+					{
 						Type: p.makeASTType(resultType, pos),
 					},
 				},
@@ -353,7 +377,7 @@ func (p *cgoPackage) addErrorAfter(pos token.Pos, after, msg string) {
 func (p *cgoPackage) addErrorAt(position token.Position, msg string) {
 	if filepath.IsAbs(position.Filename) {
 		// Relative paths for readability, like other Go parser errors.
-		relpath, err := filepath.Rel(p.dir, position.Filename)
+		relpath, err := filepath.Rel(p.currentDir, position.Filename)
 		if err == nil {
 			position.Filename = relpath
 		}
@@ -364,6 +388,41 @@ func (p *cgoPackage) addErrorAt(position token.Position, msg string) {
 	})
 }
 
+// makeDecayingASTType does the same as makeASTType but takes care of decaying
+// types (arrays in function parameters, etc). It is otherwise identical to
+// makeASTType.
+func (p *cgoPackage) makeDecayingASTType(typ C.CXType, pos token.Pos) ast.Expr {
+	// Strip typedefs, if any.
+	underlyingType := typ
+	if underlyingType.kind == C.CXType_Typedef {
+		c := C.tinygo_clang_getTypeDeclaration(typ)
+		underlyingType = C.tinygo_clang_getTypedefDeclUnderlyingType(c)
+		// TODO: support a chain of typedefs. At the moment, it seems to get
+		// stuck in an endless loop when trying to get to the most underlying
+		// type.
+	}
+	// Check for decaying type. An example would be an array type in a
+	// parameter. This declaration:
+	//   void foo(char buf[6]);
+	// is the same as this one:
+	//   void foo(char *buf);
+	// But this one:
+	//   void bar(char buf[6][4]);
+	// equals this:
+	//   void bar(char *buf[4]);
+	// so not all array dimensions should be stripped, just the first one.
+	// TODO: there are more kinds of decaying types.
+	if underlyingType.kind == C.CXType_ConstantArray {
+		// Apply type decaying.
+		pointeeType := C.clang_getElementType(underlyingType)
+		return &ast.StarExpr{
+			Star: pos,
+			X:    p.makeASTType(pointeeType, pos),
+		}
+	}
+	return p.makeASTType(typ, pos)
+}
+
 // makeASTType return the ast.Expr for the given libclang type. In other words,
 // it converts a libclang type to a type in the Go AST.
 func (p *cgoPackage) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
@@ -748,7 +807,7 @@ func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientD
 	}
 	*inBitfield = false
 	field.Names = []*ast.Ident{
-		&ast.Ident{
+		{
 			NamePos: pos,
 			Name:    name,
 			Obj: &ast.Object{
@@ -769,8 +828,18 @@ func tinygo_clang_enum_visitor(c, parent C.GoCXCursor, client_data C.CXClientDat
 	pos := p.getCursorPosition(c)
 	value := C.tinygo_clang_getEnumConstantDeclValue(c)
 	p.constants[name] = constantInfo{
-		expr: &ast.BasicLit{pos, token.INT, strconv.FormatInt(int64(value), 10)},
-		pos:  pos,
+		expr: &ast.BasicLit{
+			ValuePos: pos,
+			Kind:     token.INT,
+			Value:    strconv.FormatInt(int64(value), 10),
+		},
+		pos: pos,
 	}
 	return C.CXChildVisit_Continue
 }
+
+//export tinygo_clang_inclusion_visitor
+func tinygo_clang_inclusion_visitor(includedFile C.CXFile, inclusionStack *C.CXSourceLocation, includeLen C.unsigned, clientData C.CXClientData) {
+	callback := storedRefs.Get(unsafe.Pointer(clientData)).(func(C.CXFile))
+	callback(includedFile)
+}

cgo/libclang_config.go

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

cgo/libclang_config_llvm11.go

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

cgo/libclang_config_llvm9.go

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

cgo/libclang_stubs.c

@@ -3,7 +3,7 @@
 // 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-10-dev
+#include <clang-c/Index.h> // if this fails, install libclang-11-dev
 
 CXCursor tinygo_clang_getTranslationUnitCursor(CXTranslationUnit tu) {
 	return clang_getTranslationUnitCursor(tu);

cgo/testdata/errors.go

@@ -14,6 +14,12 @@ typedef someType noType; // undefined type
 #define SOME_CONST_2 6) // const not used (so no error)
 #define SOME_CONST_3 1234 // const too large for byte
 */
+//
+//
+// #define SOME_CONST_4 8) // after some empty lines
+import "C"
+
+// #warning another warning
 import "C"
 
 // Make sure that errors for the following lines won't change with future
@@ -30,4 +36,6 @@ var (
 	_ = C.SOME_CONST_1
 
 	_ byte = C.SOME_CONST_3
+
+	_ = C.SOME_CONST_4
 )

cgo/testdata/errors.out.go

@@ -1,13 +1,16 @@
 // CGo errors:
 //     testdata/errors.go:4:2: warning: some warning
 //     testdata/errors.go:11:9: error: unknown type name 'someType'
-//     testdata/errors.go:13:23: unexpected token )
+//     testdata/errors.go:22:5: warning: another warning
+//     testdata/errors.go:13:23: unexpected token ), expected end of expression
+//     testdata/errors.go:19:26: unexpected token ), expected end of expression
 
 // Type checking errors after CGo processing:
-//     testdata/errors.go:102: 2 << 10 (untyped int constant 2048) overflows uint8
+//     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as uint8 value in variable declaration (overflows)
 //     testdata/errors.go:105: unknown field z in struct literal
 //     testdata/errors.go:108: undeclared name: C.SOME_CONST_1
-//     testdata/errors.go:110: C.SOME_CONST_3 (untyped int constant 1234) overflows byte
+//     testdata/errors.go:110: cannot use C.SOME_CONST_3 (untyped int constant 1234) as byte value in variable declaration (overflows)
+//     testdata/errors.go:112: undeclared name: C.SOME_CONST_4
 
 package main
 

cgo/testdata/types.go

@@ -104,9 +104,17 @@ typedef struct {
 	unsigned char e : 3;
 	// Note that C++ allows bitfields bigger than the underlying type.
 } bitfield_t;
+
+// Function signatures.
+void variadic0();
+void variadic2(int x, int y, ...);
 */
 import "C"
 
+// // Test that we can refer from this CGo fragment to the fragment above.
+// typedef myint myint2;
+import "C"
+
 var (
 	// Simple typedefs.
 	_ C.myint
@@ -163,3 +171,9 @@ func accessUnion() {
 	var _ *C.int = union2d.unionfield_i()
 	var _ *[2]float64 = union2d.unionfield_d()
 }
+
+// Test function signatures.
+func accessFunctions() {
+	C.variadic0()
+	C.variadic2(3, 5)
+}

cgo/testdata/types.out.go

@@ -4,6 +4,11 @@ import "unsafe"
 
 var _ unsafe.Pointer
 
+func C.variadic0() //go:variadic
+func C.variadic2(x C.int, y C.int) //go:variadic
+var C.variadic0$funcaddr unsafe.Pointer
+var C.variadic2$funcaddr unsafe.Pointer
+
 const C.option2A = 20
 const C.optionA = 0
 const C.optionB = 1
@@ -62,9 +67,7 @@ type C.union3_t = C.union_1
 type C.union_nested_t = C.union_3
 type C.unionarray_t = struct{ arr [10]C.uchar }
 
-func (s *C.struct_4) bitfield_a() C.uchar {
-	return s.__bitfield_1 & 0x1f
-}
+func (s *C.struct_4) bitfield_a() C.uchar { return s.__bitfield_1 & 0x1f }
 func (s *C.struct_4) set_bitfield_a(value C.uchar) {
 	s.__bitfield_1 = s.__bitfield_1&^0x1f | value&0x1f<<0
 }
@@ -100,15 +103,9 @@ type C.struct_type1 struct {
 }
 type C.struct_type2 struct{ _type C.int }
 
-func (union *C.union_1) unionfield_i() *C.int {
-	return (*C.int)(unsafe.Pointer(&union.$union))
-}
-func (union *C.union_1) unionfield_d() *float64 {
-	return (*float64)(unsafe.Pointer(&union.$union))
-}
-func (union *C.union_1) unionfield_s() *C.short {
-	return (*C.short)(unsafe.Pointer(&union.$union))
-}
+func (union *C.union_1) unionfield_i() *C.int   { return (*C.int)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_1) unionfield_d() *float64 { return (*float64)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_1) unionfield_s() *C.short { return (*C.short)(unsafe.Pointer(&union.$union)) }
 
 type C.union_1 struct{ $union uint64 }
 
@@ -133,9 +130,7 @@ func (union *C.union_3) unionfield_thing() *C.union3_t {
 
 type C.union_3 struct{ $union [2]uint64 }
 
-func (union *C.union_union2d) unionfield_i() *C.int {
-	return (*C.int)(unsafe.Pointer(&union.$union))
-}
+func (union *C.union_union2d) unionfield_i() *C.int { return (*C.int)(unsafe.Pointer(&union.$union)) }
 func (union *C.union_union2d) unionfield_d() *[2]float64 {
 	return (*[2]float64)(unsafe.Pointer(&union.$union))
 }

compileopts/config.go

@@ -5,9 +5,9 @@ package compileopts
 import (
 	"errors"
 	"fmt"
+	"os"
 	"path/filepath"
 	"regexp"
-	"strconv"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/goenv"
@@ -22,30 +22,7 @@ type Config struct {
 	TestConfig     TestConfig
 }
 
-// FuncValueImplementation is an enum for the particular implementations of Go
-// func values.
-type FuncValueImplementation int
-
-// These constants describe the various possible implementations of Go func
-// values.
-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
-)
-
-// Triple returns the LLVM target triple, like armv6m-none-eabi.
+// Triple returns the LLVM target triple, like armv6m-unknown-unknown-eabi.
 func (c *Config) Triple() string {
 	return c.Target.Triple
 }
@@ -79,7 +56,7 @@ func (c *Config) GOARCH() string {
 
 // BuildTags returns the complete list of build tags used during this build.
 func (c *Config) BuildTags() []string {
-	tags := append(c.Target.BuildTags, []string{"tinygo", "gc." + c.GC(), "scheduler." + c.Scheduler()}...)
+	tags := append(c.Target.BuildTags, []string{"tinygo", "math_big_pure_go", "gc." + c.GC(), "scheduler." + c.Scheduler(), "serial." + c.Serial()}...)
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
@@ -104,12 +81,7 @@ func (c *Config) GC() string {
 	if c.Target.GC != "" {
 		return c.Target.GC
 	}
-	for _, tag := range c.Target.BuildTags {
-		if tag == "baremetal" || tag == "wasm" {
-			return "conservative"
-		}
-	}
-	return "extalloc"
+	return "conservative"
 }
 
 // NeedsStackObjects returns true if the compiler should insert stack objects
@@ -118,7 +90,7 @@ func (c *Config) NeedsStackObjects() bool {
 	switch c.GC() {
 	case "conservative", "extalloc":
 		for _, tag := range c.BuildTags() {
-			if tag == "wasm" {
+			if tag == "tinygo.wasm" {
 				return true
 			}
 		}
@@ -142,16 +114,59 @@ func (c *Config) Scheduler() string {
 	return "coroutines"
 }
 
+// Serial returns the serial implementation for this build configuration: uart,
+// usb (meaning USB-CDC), or none.
+func (c *Config) Serial() string {
+	if c.Options.Serial != "" {
+		return c.Options.Serial
+	}
+	if c.Target.Serial != "" {
+		return c.Target.Serial
+	}
+	return "none"
+}
+
+// OptLevels returns the optimization level (0-2), size level (0-2), and inliner
+// threshold as used in the LLVM optimization pipeline.
+func (c *Config) OptLevels() (optLevel, sizeLevel int, inlinerThreshold uint) {
+	switch c.Options.Opt {
+	case "none", "0":
+		return 0, 0, 0 // -O0
+	case "1":
+		return 1, 0, 0 // -O1
+	case "2":
+		return 2, 0, 225 // -O2
+	case "s":
+		return 2, 1, 225 // -Os
+	case "z":
+		return 2, 2, 5 // -Oz, default
+	default:
+		// This is not shown to the user: valid choices are already checked as
+		// part of Options.Verify(). It is here as a sanity check.
+		panic("unknown optimization level: -opt=" + c.Options.Opt)
+	}
+}
+
 // FuncImplementation picks an appropriate func value implementation for the
 // target.
-func (c *Config) FuncImplementation() FuncValueImplementation {
-	// Always pick the switch implementation, as it allows the use of blocking
-	// inside a function that is used as a func value.
+func (c *Config) FuncImplementation() string {
 	switch c.Scheduler() {
-	case "none", "coroutines":
-		return FuncValueSwitch
 	case "tasks":
-		return FuncValueDoubleword
+		// 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.
+		return "doubleword"
+	case "none", "coroutines":
+		// As "doubleword", 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.
+		// Pick the switch implementation with the coroutines scheduler, as it
+		// allows the use of blocking inside a function that is used as a func
+		// value.
+		return "switch"
 	default:
 		panic("unknown scheduler type")
 	}
@@ -174,20 +189,102 @@ func (c *Config) AutomaticStackSize() bool {
 	return false
 }
 
+// RP2040BootPatch returns whether the RP2040 boot patch should be applied that
+// calculates and patches in the checksum for the 2nd stage bootloader.
+func (c *Config) RP2040BootPatch() bool {
+	if c.Target.RP2040BootPatch != nil {
+		return *c.Target.RP2040BootPatch
+	}
+	return false
+}
+
+// MuslArchitecture returns the architecture name as used in musl libc. It is
+// usually the same as the first part of the LLVM triple, but not always.
+func MuslArchitecture(triple string) string {
+	arch := strings.Split(triple, "-")[0]
+	if strings.HasPrefix(arch, "arm") || strings.HasPrefix(arch, "thumb") {
+		arch = "arm"
+	}
+	return arch
+}
+
+// LibcPath returns the path to the libc directory. The libc path will be either
+// a precompiled libc shipped with a TinyGo build, or a libc path in the cache
+// directory (which might not yet be built).
+func (c *Config) LibcPath(name string) (path string, precompiled bool) {
+	// Try to load a precompiled library.
+	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", c.Triple(), name)
+	if _, err := os.Stat(precompiledDir); err == nil {
+		// Found a precompiled library for this OS/architecture. Return the path
+		// directly.
+		return precompiledDir, true
+	}
+
+	// No precompiled library found. Determine the path name that will be used
+	// in the build cache.
+	var outname string
+	if c.CPU() != "" {
+		outname = name + "-" + c.Triple() + "-" + c.CPU()
+	} else {
+		outname = name + "-" + c.Triple()
+	}
+	return filepath.Join(goenv.Get("GOCACHE"), outname), false
+}
+
 // CFlags returns the flags to pass to the C compiler. This is necessary for CGo
 // preprocessing.
 func (c *Config) CFlags() []string {
-	cflags := append([]string{}, c.Options.CFlags...)
+	var cflags []string
 	for _, flag := range c.Target.CFlags {
-		cflags = append(cflags, strings.Replace(flag, "{root}", goenv.Get("TINYGOROOT"), -1))
+		cflags = append(cflags, strings.ReplaceAll(flag, "{root}", goenv.Get("TINYGOROOT")))
 	}
-	if c.Target.Libc == "picolibc" {
+	switch c.Target.Libc {
+	case "picolibc":
 		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags, "-nostdlibinc", "-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "picolibc", "newlib", "libc", "include"))
-		cflags = append(cflags, "-I"+filepath.Join(root, "lib/picolibc-include"))
+		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
+		path, _ := c.LibcPath("picolibc")
+		cflags = append(cflags,
+			"--sysroot="+path,
+			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(picolibcDir, "include"),
+			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(picolibcDir, "tinystdio"),
+		)
+	case "musl":
+		root := goenv.Get("TINYGOROOT")
+		path, _ := c.LibcPath("musl")
+		arch := MuslArchitecture(c.Triple())
+		cflags = append(cflags,
+			"--sysroot="+path,
+			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "musl", "arch", arch),
+			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "musl", "include"),
+		)
+	case "wasi-libc":
+		root := goenv.Get("TINYGOROOT")
+		cflags = append(cflags, "--sysroot="+root+"/lib/wasi-libc/sysroot")
+	case "":
+		// No libc specified, nothing to add.
+	default:
+		// Incorrect configuration. This could be handled in a better way, but
+		// usually this will be found by developers (not by TinyGo users).
+		panic("unknown libc: " + c.Target.Libc)
 	}
-	if c.Debug() {
-		cflags = append(cflags, "-g")
+	// Always emit debug information. It is optionally stripped at link time.
+	cflags = append(cflags, "-g")
+	// Use the same optimization level as TinyGo.
+	cflags = append(cflags, "-O"+c.Options.Opt)
+	// Set the LLVM target triple.
+	cflags = append(cflags, "--target="+c.Triple())
+	// Set the -mcpu (or similar) flag.
+	if c.Target.CPU != "" {
+		if c.GOARCH() == "amd64" || c.GOARCH() == "386" {
+			// x86 prefers the -march flag (-mcpu is deprecated there).
+			cflags = append(cflags, "-march="+c.Target.CPU)
+		} else if strings.HasPrefix(c.Triple(), "avr") {
+			// AVR MCUs use -mmcu instead of -mcpu.
+			cflags = append(cflags, "-mmcu="+c.Target.CPU)
+		} else {
+			// The rest just uses -mcpu.
+			cflags = append(cflags, "-mcpu="+c.Target.CPU)
+		}
 	}
 	return cflags
 }
@@ -198,17 +295,11 @@ func (c *Config) CFlags() []string {
 func (c *Config) LDFlags() []string {
 	root := goenv.Get("TINYGOROOT")
 	// Merge and adjust LDFlags.
-	ldflags := append([]string{}, c.Options.LDFlags...)
+	var ldflags []string
 	for _, flag := range c.Target.LDFlags {
-		ldflags = append(ldflags, strings.Replace(flag, "{root}", root, -1))
+		ldflags = append(ldflags, strings.ReplaceAll(flag, "{root}", root))
 	}
 	ldflags = append(ldflags, "-L", root)
-	if c.Target.GOARCH == "wasm" {
-		// Round heap size to next multiple of 65536 (the WebAssembly page
-		// size).
-		heapSize := (c.Options.HeapSize + (65536 - 1)) &^ (65536 - 1)
-		ldflags = append(ldflags, "--initial-memory="+strconv.FormatInt(heapSize, 10))
-	}
 	if c.Target.LinkerScript != "" {
 		ldflags = append(ldflags, "-T", c.Target.LinkerScript)
 	}
@@ -233,8 +324,9 @@ func (c *Config) VerifyIR() bool {
 	return c.Options.VerifyIR
 }
 
-// Debug returns whether to add debug symbols to the IR, for debugging with GDB
-// and similar.
+// Debug returns whether debug (DWARF) information should be retained by the
+// linker. By default, debug information is retained but it can be removed with
+// the -no-debug flag.
 func (c *Config) Debug() bool {
 	return c.Options.Debug
 }
@@ -258,6 +350,11 @@ func (c *Config) BinaryFormat(ext string) string {
 		// More information:
 		// https://github.com/Microsoft/uf2
 		return "uf2"
+	case ".zip":
+		if c.Target.BinaryFormat != "" {
+			return c.Target.BinaryFormat
+		}
+		return "zip"
 	default:
 		// Use the ELF format for unrecognized file formats.
 		return "elf"
@@ -275,6 +372,9 @@ func (c *Config) Programmer() (method, openocdInterface string) {
 	case "openocd", "msd", "command":
 		// The -programmer flag only specifies the flash method.
 		return c.Options.Programmer, c.Target.OpenOCDInterface
+	case "bmp":
+		// The -programmer flag only specifies the flash method.
+		return c.Options.Programmer, ""
 	default:
 		// The -programmer flag specifies something else, assume it specifies
 		// the OpenOCD interface name.
@@ -303,6 +403,9 @@ func (c *Config) OpenOCDConfiguration() (args []string, err error) {
 		return nil, fmt.Errorf("unknown OpenOCD transport: %#v", c.Target.OpenOCDTransport)
 	}
 	args = []string{"-f", "interface/" + openocdInterface + ".cfg"}
+	for _, cmd := range c.Target.OpenOCDCommands {
+		args = append(args, "-c", cmd)
+	}
 	if c.Target.OpenOCDTransport != "" {
 		args = append(args, "-c", "transport select "+c.Target.OpenOCDTransport)
 	}
@@ -338,6 +441,10 @@ func (c *Config) WasmAbi() string {
 	return c.Target.WasmAbi
 }
 
+func (c *Config) LLVMFeatures() string {
+	return c.Options.LLVMFeatures
+}
+
 type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc

compileopts/options.go

@@ -2,37 +2,47 @@ package compileopts
 
 import (
 	"fmt"
+	"regexp"
 	"strings"
 )
 
 var (
 	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
 	validSchedulerOptions     = []string{"none", "tasks", "coroutines"}
+	validSerialOptions        = []string{"none", "uart", "usb"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
 	validPanicStrategyOptions = []string{"print", "trap"}
+	validOptOptions           = []string{"none", "0", "1", "2", "s", "z"}
 )
 
 // Options contains extra options to give to the compiler. These options are
-// usually passed from the command line.
+// usually passed from the command line, but can also be passed in environment
+// variables for example.
 type Options struct {
-	Target        string
-	Opt           string
-	GC            string
-	PanicStrategy string
-	Scheduler     string
-	PrintIR       bool
-	DumpSSA       bool
-	VerifyIR      bool
-	Debug         bool
-	PrintSizes    string
-	PrintStacks   bool
-	CFlags        []string
-	LDFlags       []string
-	Tags          string
-	WasmAbi       string
-	HeapSize      int64
-	TestConfig    TestConfig
-	Programmer    string
+	GOOS            string // environment variable
+	GOARCH          string // environment variable
+	Target          string
+	Opt             string
+	GC              string
+	PanicStrategy   string
+	Scheduler       string
+	Serial          string
+	PrintIR         bool
+	DumpSSA         bool
+	VerifyIR        bool
+	PrintCommands   func(cmd string, args ...string)
+	Parallelism     int // -p flag
+	Debug           bool
+	PrintSizes      string
+	PrintAllocs     *regexp.Regexp // regexp string
+	PrintStacks     bool
+	Tags            string
+	WasmAbi         string
+	GlobalValues    map[string]map[string]string // map[pkgpath]map[varname]value
+	TestConfig      TestConfig
+	Programmer      string
+	OpenOCDCommands []string
+	LLVMFeatures    string
 }
 
 // Verify performs a validation on the given options, raising an error if options are not valid.
@@ -55,6 +65,15 @@ func (o *Options) Verify() error {
 		}
 	}
 
+	if o.Serial != "" {
+		valid := isInArray(validSerialOptions, o.Serial)
+		if !valid {
+			return fmt.Errorf(`invalid serial option '%s': valid values are %s`,
+				o.Serial,
+				strings.Join(validSerialOptions, ", "))
+		}
+	}
+
 	if o.PrintSizes != "" {
 		valid := isInArray(validPrintSizeOptions, o.PrintSizes)
 		if !valid {
@@ -73,6 +92,12 @@ func (o *Options) Verify() error {
 		}
 	}
 
+	if o.Opt != "" {
+		if !isInArray(validOptOptions, o.Opt) {
+			return fmt.Errorf("invalid -opt=%s: valid values are %s", o.Opt, strings.Join(validOptOptions, ", "))
+		}
+	}
+
 	return nil
 }
 

compileopts/target.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"io"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"reflect"
 	"runtime"
@@ -30,7 +31,7 @@ type TargetSpec struct {
 	BuildTags        []string `json:"build-tags"`
 	GC               string   `json:"gc"`
 	Scheduler        string   `json:"scheduler"`
-	Compiler         string   `json:"compiler"`
+	Serial           string   `json:"serial"` // which serial output to use (uart, usb, none)
 	Linker           string   `json:"linker"`
 	RTLib            string   `json:"rtlib"` // compiler runtime library (libgcc, compiler-rt)
 	Libc             string   `json:"libc"`
@@ -40,10 +41,12 @@ type TargetSpec struct {
 	LDFlags          []string `json:"ldflags"`
 	LinkerScript     string   `json:"linkerscript"`
 	ExtraFiles       []string `json:"extra-files"`
+	RP2040BootPatch  *bool    `json:"rp2040-boot-patch"`        // Patch RP2040 2nd stage bootloader checksum
 	Emulator         []string `json:"emulator" override:"copy"` // inherited Emulator must not be append
 	FlashCommand     string   `json:"flash-command"`
-	GDB              string   `json:"gdb"`
+	GDB              []string `json:"gdb"`
 	PortReset        string   `json:"flash-1200-bps-reset"`
+	SerialPort       []string `json:"serial-port"` // serial port IDs in the form "acm:vid:pid" or "usb:vid:pid"
 	FlashMethod      string   `json:"flash-method"`
 	FlashVolume      string   `json:"msd-volume-name"`
 	FlashFilename    string   `json:"msd-firmware-name"`
@@ -52,6 +55,7 @@ type TargetSpec struct {
 	OpenOCDInterface string   `json:"openocd-interface"`
 	OpenOCDTarget    string   `json:"openocd-target"`
 	OpenOCDTransport string   `json:"openocd-transport"`
+	OpenOCDCommands  []string `json:"openocd-commands"`
 	JLinkDevice      string   `json:"jlink-device"`
 	CodeModel        string   `json:"code-model"`
 	RelocationModel  string   `json:"relocation-model"`
@@ -157,116 +161,124 @@ func (spec *TargetSpec) resolveInherits() error {
 }
 
 // Load a target specification.
-func LoadTarget(target string) (*TargetSpec, error) {
-	if target == "" {
+func LoadTarget(options *Options) (*TargetSpec, error) {
+	if options.Target == "" {
 		// Configure based on GOOS/GOARCH environment variables (falling back to
 		// runtime.GOOS/runtime.GOARCH), and generate a LLVM target based on it.
-		goos := goenv.Get("GOOS")
-		goarch := goenv.Get("GOARCH")
-		llvmos := goos
 		llvmarch := map[string]string{
 			"386":   "i386",
 			"amd64": "x86_64",
 			"arm64": "aarch64",
-		}[goarch]
+			"arm":   "armv7",
+		}[options.GOARCH]
 		if llvmarch == "" {
-			llvmarch = goarch
+			llvmarch = options.GOARCH
 		}
-		target = llvmarch + "--" + llvmos
-		if goarch == "arm" {
+		llvmos := options.GOOS
+		if llvmos == "darwin" {
+			// Use macosx* instead of darwin, otherwise darwin/arm64 will refer
+			// to iOS!
+			llvmos = "macosx10.12.0"
+			if llvmarch == "aarch64" {
+				// Looks like Apple prefers to call this architecture ARM64
+				// instead of AArch64.
+				llvmarch = "arm64"
+			}
+		}
+		// Target triples (which actually have four components, but are called
+		// triples for historical reasons) have the form:
+		//   arch-vendor-os-environment
+		target := llvmarch + "-unknown-" + llvmos
+		if options.GOARCH == "arm" {
 			target += "-gnueabihf"
 		}
-		return defaultTarget(goos, goarch, target)
+		return defaultTarget(options.GOOS, options.GOARCH, target)
 	}
 
 	// See whether there is a target specification for this target (e.g.
 	// Arduino).
 	spec := &TargetSpec{}
-	err := spec.loadFromGivenStr(target)
-	if err == nil {
-		// Successfully loaded this target from a built-in .json file. Make sure
-		// it includes all parents as specified in the "inherits" key.
-		err = spec.resolveInherits()
-		if err != nil {
-			return nil, err
-		}
-		return spec, nil
-	} else if !os.IsNotExist(err) {
-		// Expected a 'file not found' error, got something else. Report it as
-		// an error.
+	err := spec.loadFromGivenStr(options.Target)
+	if err != nil {
 		return nil, err
-	} else {
-		// Load target from given triple, ignore GOOS/GOARCH environment
-		// variables.
-		tripleSplit := strings.Split(target, "-")
-		if len(tripleSplit) < 3 {
-			return nil, errors.New("expected a full LLVM target or a custom target in -target flag")
-		}
-		if tripleSplit[0] == "arm" {
-			// LLVM and Clang have a different idea of what "arm" means, so
-			// upgrade to a slightly more modern ARM. In fact, when you pass
-			// --target=arm--linux-gnueabihf to Clang, it will convert that
-			// internally to armv7-unknown-linux-gnueabihf. Changing the
-			// architecture to armv7 will keep things consistent.
-			tripleSplit[0] = "armv7"
-		}
-		goos := tripleSplit[2]
-		if strings.HasPrefix(goos, "darwin") {
-			goos = "darwin"
-		}
-		goarch := map[string]string{ // map from LLVM arch to Go arch
-			"i386":    "386",
-			"i686":    "386",
-			"x86_64":  "amd64",
-			"aarch64": "arm64",
-			"armv7":   "arm",
-		}[tripleSplit[0]]
-		if goarch == "" {
-			goarch = tripleSplit[0]
-		}
-		return defaultTarget(goos, goarch, strings.Join(tripleSplit, "-"))
 	}
+	// Successfully loaded this target from a built-in .json file. Make sure
+	// it includes all parents as specified in the "inherits" key.
+	err = spec.resolveInherits()
+	if err != nil {
+		return nil, err
+	}
+	return spec, nil
 }
 
+// WindowsBuildNotSupportedErr is being thrown, when goos is windows and no target has been specified.
+var WindowsBuildNotSupportedErr = errors.New("Building Windows binaries is currently not supported. Try specifying a different target")
+
 func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
+	if goos == "windows" {
+		return nil, WindowsBuildNotSupportedErr
+	}
 	// No target spec available. Use the default one, useful on most systems
 	// with a regular OS.
 	spec := TargetSpec{
-		Triple:    triple,
-		GOOS:      goos,
-		GOARCH:    goarch,
-		BuildTags: []string{goos, goarch},
-		Compiler:  "clang",
-		Linker:    "cc",
-		CFlags:    []string{"--target=" + triple},
-		GDB:       "gdb",
-		PortReset: "false",
+		Triple:           triple,
+		GOOS:             goos,
+		GOARCH:           goarch,
+		BuildTags:        []string{goos, goarch},
+		Scheduler:        "tasks",
+		Linker:           "cc",
+		DefaultStackSize: 1024 * 64, // 64kB
+		GDB:              []string{"gdb"},
+		PortReset:        "false",
+	}
+	switch goarch {
+	case "386":
+		spec.CPU = "pentium4"
+	case "amd64":
+		spec.CPU = "x86-64"
+	case "arm":
+		spec.CPU = "generic"
+	case "arm64":
+		spec.CPU = "generic"
 	}
 	if goos == "darwin" {
+		spec.CFlags = append(spec.CFlags, "-isysroot", "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk")
 		spec.LDFlags = append(spec.LDFlags, "-Wl,-dead_strip")
+	} else if goos == "linux" {
+		spec.Linker = "ld.lld"
+		spec.RTLib = "compiler-rt"
+		spec.Libc = "musl"
+		spec.LDFlags = append(spec.LDFlags, "--gc-sections")
 	} else {
 		spec.LDFlags = append(spec.LDFlags, "-no-pie", "-Wl,--gc-sections") // WARNING: clang < 5.0 requires -nopie
 	}
 	if goarch != "wasm" {
 		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/gc_"+goarch+".S")
+		spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_stack_"+goarch+".S")
 	}
 	if goarch != runtime.GOARCH {
 		// Some educated guesses as to how to invoke helper programs.
-		spec.GDB = "gdb-multiarch"
+		spec.GDB = []string{"gdb-multiarch"}
 		if goarch == "arm" && goos == "linux" {
-			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/arm-linux-gnueabihf")
-			spec.Linker = "arm-linux-gnueabihf-gcc"
-			spec.Emulator = []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}
+			spec.Emulator = []string{"qemu-arm"}
 		}
 		if goarch == "arm64" && goos == "linux" {
-			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/aarch64-linux-gnu")
-			spec.Linker = "aarch64-linux-gnu-gcc"
-			spec.Emulator = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
-		}
-		if goarch == "386" && runtime.GOARCH == "amd64" {
-			spec.CFlags = append(spec.CFlags, "-m32")
-			spec.LDFlags = append(spec.LDFlags, "-m32")
+			spec.Emulator = []string{"qemu-aarch64"}
 		}
 	}
 	return &spec, nil
 }
+
+// LookupGDB looks up a gdb executable.
+func (spec *TargetSpec) LookupGDB() (string, error) {
+	if len(spec.GDB) == 0 {
+		return "", errors.New("gdb not configured in the target specification")
+	}
+	for _, d := range spec.GDB {
+		_, err := exec.LookPath(d)
+		if err == nil {
+			return d, nil
+		}
+	}
+	return "", errors.New("no gdb found configured in the target specification (" + strings.Join(spec.GDB, ", ") + ")")
+}

compileopts/target_test.go

@@ -1,22 +1,23 @@
 package compileopts
 
 import (
+	"os"
 	"reflect"
 	"testing"
 )
 
 func TestLoadTarget(t *testing.T) {
-	_, err := LoadTarget("arduino")
+	_, err := LoadTarget(&Options{Target: "arduino"})
 	if err != nil {
 		t.Error("LoadTarget test failed:", err)
 	}
 
-	_, err = LoadTarget("notexist")
+	_, err = LoadTarget(&Options{Target: "notexist"})
 	if err == nil {
 		t.Error("LoadTarget should have failed with non existing target")
 	}
 
-	if err.Error() != "expected a full LLVM target or a custom target in -target flag" {
+	if !os.IsNotExist(err) {
 		t.Error("LoadTarget failed for wrong reason:", err)
 	}
 }

compiler/alias.go

@@ -0,0 +1,102 @@
+package compiler
+
+// This file defines alias functions for functions that are normally defined in
+// Go assembly.
+//
+// The Go toolchain defines many performance critical functions in assembly
+// instead of plain Go. This is a problem for TinyGo as it currently (as of
+// august 2021) is not able to compile these assembly files and even if it
+// could, it would not be able to make use of them for many targets that are
+// supported by TinyGo (baremetal RISC-V, AVR, etc). Therefore, many of these
+// functions are aliased to their generic Go implementation.
+// This results in slower than possible implementations, but at least they are
+// usable.
+
+import "tinygo.org/x/go-llvm"
+
+var stdlibAliases = map[string]string{
+	// crypto packages
+	"crypto/md5.block":         "crypto/md5.blockGeneric",
+	"crypto/sha1.block":        "crypto/sha1.blockGeneric",
+	"crypto/sha1.blockAMD64":   "crypto/sha1.blockGeneric",
+	"crypto/sha256.block":      "crypto/sha256.blockGeneric",
+	"crypto/sha512.blockAMD64": "crypto/sha512.blockGeneric",
+
+	// math package
+	"math.Asin":      "math.asin",
+	"math.Asinh":     "math.asinh",
+	"math.Acos":      "math.acos",
+	"math.Acosh":     "math.acosh",
+	"math.Atan":      "math.atan",
+	"math.Atanh":     "math.atanh",
+	"math.Atan2":     "math.atan2",
+	"math.Cbrt":      "math.cbrt",
+	"math.Ceil":      "math.ceil",
+	"math.archCeil":  "math.ceil",
+	"math.Cos":       "math.cos",
+	"math.Cosh":      "math.cosh",
+	"math.Erf":       "math.erf",
+	"math.Erfc":      "math.erfc",
+	"math.Exp":       "math.exp",
+	"math.archExp":   "math.exp",
+	"math.Expm1":     "math.expm1",
+	"math.Exp2":      "math.exp2",
+	"math.archExp2":  "math.exp2",
+	"math.Floor":     "math.floor",
+	"math.archFloor": "math.floor",
+	"math.Frexp":     "math.frexp",
+	"math.Hypot":     "math.hypot",
+	"math.archHypot": "math.hypot",
+	"math.Ldexp":     "math.ldexp",
+	"math.Log":       "math.log",
+	"math.archLog":   "math.log",
+	"math.Log1p":     "math.log1p",
+	"math.Log10":     "math.log10",
+	"math.Log2":      "math.log2",
+	"math.Max":       "math.max",
+	"math.archMax":   "math.max",
+	"math.Min":       "math.min",
+	"math.archMin":   "math.min",
+	"math.Mod":       "math.mod",
+	"math.Modf":      "math.modf",
+	"math.archModf":  "math.modf",
+	"math.Pow":       "math.pow",
+	"math.Remainder": "math.remainder",
+	"math.Sin":       "math.sin",
+	"math.Sinh":      "math.sinh",
+	"math.Sqrt":      "math.sqrt",
+	"math.archSqrt":  "math.sqrt",
+	"math.Tan":       "math.tan",
+	"math.Tanh":      "math.tanh",
+	"math.Trunc":     "math.trunc",
+	"math.archTrunc": "math.trunc",
+}
+
+// createAlias implements the function (in the builder) as a call to the alias
+// function.
+func (b *builder) createAlias(alias llvm.Value) {
+	b.llvmFn.SetVisibility(llvm.HiddenVisibility)
+	b.llvmFn.SetUnnamedAddr(true)
+
+	if b.Debug {
+		if b.fn.Syntax() != nil {
+			// Create debug info file if present.
+			b.difunc = b.attachDebugInfo(b.fn)
+		}
+		pos := b.program.Fset.Position(b.fn.Pos())
+		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
+	}
+	entryBlock := llvm.AddBasicBlock(b.llvmFn, "entry")
+	b.SetInsertPointAtEnd(entryBlock)
+	if b.llvmFn.Type() != alias.Type() {
+		b.addError(b.fn.Pos(), "alias function should have the same type as aliasee "+alias.Name())
+		b.CreateUnreachable()
+		return
+	}
+	result := b.CreateCall(alias, b.llvmFn.Params(), "")
+	if result.Type().TypeKind() == llvm.VoidTypeKind {
+		b.CreateRetVoid()
+	} else {
+		b.CreateRet(result)
+	}
+}

compiler/asserts.go

@@ -16,7 +16,7 @@ import (
 // slice. This is required by the Go language spec: an index out of bounds must
 // cause a panic.
 func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType types.Type) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -48,7 +48,7 @@ func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType
 // biggest possible slice capacity, 'low' means len and 'high' means cap. The
 // logic is the same in both cases.
 func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lowType, highType, maxType *types.Basic) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -101,10 +101,59 @@ func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lo
 	b.createRuntimeAssert(outOfBounds, "slice", "slicePanic")
 }
 
+// createSliceToArrayPointerCheck adds a check for slice-to-array pointer
+// conversions. This conversion was added in Go 1.17. For details, see:
+// https://tip.golang.org/ref/spec#Conversions_from_slice_to_array_pointer
+func (b *builder) createSliceToArrayPointerCheck(sliceLen llvm.Value, arrayLen int64) {
+	// From the spec:
+	// > If the length of the slice is less than the length of the array, a
+	// > run-time panic occurs.
+	arrayLenValue := llvm.ConstInt(b.uintptrType, uint64(arrayLen), false)
+	isLess := b.CreateICmp(llvm.IntULT, sliceLen, arrayLenValue, "")
+	b.createRuntimeAssert(isLess, "slicetoarray", "sliceToArrayPointerPanic")
+}
+
+// createUnsafeSliceCheck inserts a runtime check used for unsafe.Slice. This
+// function must panic if the ptr/len parameters are invalid.
+func (b *builder) createUnsafeSliceCheck(ptr, len llvm.Value, lenType *types.Basic) {
+	// From the documentation of unsafe.Slice:
+	//   > At run time, if len is negative, or if ptr is nil and len is not
+	//   > zero, a run-time panic occurs.
+	// However, in practice, it is also necessary to check that the length is
+	// not too big that a GEP wouldn't be possible without wrapping the pointer.
+	// These two checks (non-negative and not too big) can be merged into one
+	// using an unsiged greater than.
+
+	// Make sure the len value is at least as big as a uintptr.
+	if len.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
+		if lenType.Info()&types.IsUnsigned != 0 {
+			len = b.CreateZExt(len, b.uintptrType, "")
+		} else {
+			len = b.CreateSExt(len, b.uintptrType, "")
+		}
+	}
+
+	// Determine the maximum slice size, and therefore the maximum value of the
+	// len parameter.
+	maxSize := b.maxSliceSize(ptr.Type().ElementType())
+	maxSizeValue := llvm.ConstInt(len.Type(), maxSize, false)
+
+	// Do the check. By using unsigned greater than for the length check, signed
+	// negative values are also checked (which are very large numbers when
+	// interpreted as signed values).
+	zero := llvm.ConstInt(len.Type(), 0, false)
+	lenOutOfBounds := b.CreateICmp(llvm.IntUGT, len, maxSizeValue, "")
+	ptrIsNil := b.CreateICmp(llvm.IntEQ, ptr, llvm.ConstNull(ptr.Type()), "")
+	lenIsNotZero := b.CreateICmp(llvm.IntNE, len, zero, "")
+	assert := b.CreateAnd(ptrIsNil, lenIsNotZero, "")
+	assert = b.CreateOr(assert, lenOutOfBounds, "")
+	b.createRuntimeAssert(assert, "unsafe.Slice", "unsafeSlicePanic")
+}
+
 // createChanBoundsCheck creates a bounds check before creating a new channel to
 // check that the value is not too big for runtime.chanMake.
 func (b *builder) createChanBoundsCheck(elementSize uint64, bufSize llvm.Value, bufSizeType *types.Basic, pos token.Pos) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
@@ -115,11 +164,9 @@ func (b *builder) createChanBoundsCheck(elementSize uint64, bufSize llvm.Value,
 	if bufSize.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
 		if bufSizeType.Info()&types.IsUnsigned != 0 {
 			// Unsigned, so zero-extend to uint type.
-			bufSizeType = types.Typ[types.Uint]
 			bufSize = b.CreateZExt(bufSize, b.intType, "")
 		} else {
 			// Signed, so sign-extend to int type.
-			bufSizeType = types.Typ[types.Int]
 			bufSize = b.CreateSExt(bufSize, b.intType, "")
 		}
 	}
@@ -159,6 +206,13 @@ func (b *builder) createNilCheck(inst ssa.Value, ptr llvm.Value, blockPrefix str
 	}
 
 	switch inst := inst.(type) {
+	case *ssa.Alloc:
+		// An alloc is never nil.
+		return
+	case *ssa.FreeVar:
+		// A free variable is allocated in a parent function and is thus never
+		// nil.
+		return
 	case *ssa.IndexAddr:
 		// This pointer is the result of an index operation into a slice or
 		// array. Such slices/arrays are already bounds checked so the pointer
@@ -189,7 +243,7 @@ func (b *builder) createNilCheck(inst ssa.Value, ptr llvm.Value, blockPrefix str
 // createNegativeShiftCheck creates an assertion that panics if the given shift value is negative.
 // This function assumes that the shift value is signed.
 func (b *builder) createNegativeShiftCheck(shift llvm.Value) {
-	if b.fn.IsNoBounds() {
+	if b.info.nobounds {
 		// Function disabled bounds checking - skip shift check.
 		return
 	}
@@ -199,6 +253,19 @@ func (b *builder) createNegativeShiftCheck(shift llvm.Value) {
 	b.createRuntimeAssert(isNegative, "shift", "negativeShiftPanic")
 }
 
+// createDivideByZeroCheck asserts that y is not zero. If it is, a runtime panic
+// will be emitted. This follows the Go specification which says that a divide
+// by zero must cause a run time panic.
+func (b *builder) createDivideByZeroCheck(y llvm.Value) {
+	if b.info.nobounds {
+		return
+	}
+
+	// isZero = y == 0
+	isZero := b.CreateICmp(llvm.IntEQ, y, llvm.ConstInt(y.Type(), 0, false), "")
+	b.createRuntimeAssert(isZero, "divbyzero", "divideByZeroPanic")
+}
+
 // createRuntimeAssert is a common function to create a new branch on an assert
 // bool, calling an assert func if the assert value is true (1).
 func (b *builder) createRuntimeAssert(assert llvm.Value, blockPrefix, assertFunc string) {
@@ -212,8 +279,8 @@ func (b *builder) createRuntimeAssert(assert llvm.Value, blockPrefix, assertFunc
 		}
 	}
 
-	faultBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, blockPrefix+".throw")
-	nextBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, blockPrefix+".next")
+	faultBlock := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".throw")
+	nextBlock := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".next")
 	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
 
 	// Now branch to the out-of-bounds or the regular block.

compiler/atomic.go

@@ -1,6 +1,8 @@
 package compiler
 
 import (
+	"strings"
+
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -35,6 +37,30 @@ func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
 		ptr := b.getValue(call.Args[0])
 		old := b.getValue(call.Args[1])
 		newVal := b.getValue(call.Args[2])
+		if strings.HasSuffix(name, "64") {
+			if strings.HasPrefix(b.Triple, "thumb") {
+				// Work around a bug in LLVM, at least LLVM 11:
+				// https://reviews.llvm.org/D95891
+				// Check for thumbv6m, thumbv7, thumbv7em, and perhaps others.
+				// See also: https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html
+				compareAndSwap := b.mod.NamedFunction("__sync_val_compare_and_swap_8")
+				if compareAndSwap.IsNil() {
+					// Declare the function if it isn't already declared.
+					i64Type := b.ctx.Int64Type()
+					fnType := llvm.FunctionType(i64Type, []llvm.Type{llvm.PointerType(i64Type, 0), i64Type, i64Type}, false)
+					compareAndSwap = llvm.AddFunction(b.mod, "__sync_val_compare_and_swap_8", fnType)
+				}
+				actualOldValue := b.CreateCall(compareAndSwap, []llvm.Value{ptr, old, newVal}, "")
+				// The __sync_val_compare_and_swap_8 function returns the old
+				// value. However, we shouldn't return the old value, we should
+				// return whether the compare/exchange was successful. This is
+				// easily done by comparing the returned (actual) old value with
+				// the expected old value passed to
+				// __sync_val_compare_and_swap_8.
+				swapped := b.CreateICmp(llvm.IntEQ, old, actualOldValue, "")
+				return swapped, true
+			}
+		}
 		tuple := b.CreateAtomicCmpXchg(ptr, old, newVal, llvm.AtomicOrderingSequentiallyConsistent, llvm.AtomicOrderingSequentiallyConsistent, true)
 		swapped := b.CreateExtractValue(tuple, 1, "")
 		return swapped, true

compiler/calls.go

@@ -4,6 +4,7 @@ import (
 	"go/types"
 	"strconv"
 
+	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -34,14 +35,14 @@ const (
 
 // createCall creates a new call to runtime.<fnName> with the given arguments.
 func (b *builder) createRuntimeCall(fnName string, args []llvm.Value, name string) llvm.Value {
-	fullName := "runtime." + fnName
-	fn := b.mod.NamedFunction(fullName)
-	if fn.IsNil() {
-		panic("trying to call non-existent function: " + fullName)
+	fn := b.program.ImportedPackage("runtime").Members[fnName].(*ssa.Function)
+	llvmFn := b.getFunction(fn)
+	if llvmFn.IsNil() {
+		panic("trying to call non-existent function: " + fn.RelString(nil))
 	}
 	args = append(args, llvm.Undef(b.i8ptrType))            // unused context parameter
 	args = append(args, llvm.ConstPointerNull(b.i8ptrType)) // coroutine handle
-	return b.createCall(fn, args, name)
+	return b.createCall(llvmFn, args, name)
 }
 
 // createCall creates a call to the given function with the arguments possibly
@@ -57,15 +58,15 @@ func (b *builder) createCall(fn llvm.Value, args []llvm.Value, name string) llvm
 
 // Expand an argument type to a list that can be used in a function call
 // parameter list.
-func expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
+func (c *compilerContext) expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fieldInfos := flattenAggregateType(t, name, goType)
+		fieldInfos := c.flattenAggregateType(t, name, goType)
 		if len(fieldInfos) <= maxFieldsPerParam {
+			// managed to expand this parameter
 			return fieldInfos
-		} else {
-			// failed to lower
 		}
+		// failed to expand this parameter: too many fields
 	}
 	// TODO: split small arrays
 	return []paramInfo{
@@ -104,7 +105,7 @@ func (b *builder) expandFormalParamOffsets(t llvm.Type) []uint64 {
 func (b *builder) expandFormalParam(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
-		fieldInfos := flattenAggregateType(v.Type(), "", nil)
+		fieldInfos := b.flattenAggregateType(v.Type(), "", nil)
 		if len(fieldInfos) <= maxFieldsPerParam {
 			fields := b.flattenAggregate(v)
 			if len(fields) != len(fieldInfos) {
@@ -123,12 +124,15 @@ func (b *builder) expandFormalParam(v llvm.Value) []llvm.Value {
 
 // Try to flatten a struct type to a list of types. Returns a 1-element slice
 // with the passed in type if this is not possible.
-func flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
+func (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
 	typeFlags := getTypeFlags(goType)
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		paramInfos := make([]paramInfo, 0, t.StructElementTypesCount())
+		var paramInfos []paramInfo
 		for i, subfield := range t.StructElementTypes() {
+			if c.targetData.TypeAllocSize(subfield) == 0 {
+				continue
+			}
 			suffix := strconv.Itoa(i)
 			if goType != nil {
 				// Try to come up with a good suffix for this struct field,
@@ -151,7 +155,7 @@ func flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramIn
 					suffix = []string{"context", "funcptr"}[i]
 				}
 			}
-			subInfos := flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
+			subInfos := c.flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
 			for i := range subInfos {
 				subInfos[i].flags |= typeFlags
 			}
@@ -217,8 +221,11 @@ func extractSubfield(t types.Type, field int) types.Type {
 func (c *compilerContext) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fields := make([]uint64, 0, t.StructElementTypesCount())
+		var fields []uint64
 		for fieldIndex, field := range t.StructElementTypes() {
+			if c.targetData.TypeAllocSize(field) == 0 {
+				continue
+			}
 			suboffsets := c.flattenAggregateTypeOffsets(field)
 			offset := c.targetData.ElementOffset(t, fieldIndex)
 			for i := range suboffsets {
@@ -237,8 +244,11 @@ func (c *compilerContext) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 func (b *builder) flattenAggregate(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
-		fields := make([]llvm.Value, 0, v.Type().StructElementTypesCount())
-		for i := range v.Type().StructElementTypes() {
+		var fields []llvm.Value
+		for i, field := range v.Type().StructElementTypes() {
+			if b.targetData.TypeAllocSize(field) == 0 {
+				continue
+			}
 			subfield := b.CreateExtractValue(v, i, "")
 			subfields := b.flattenAggregate(subfield)
 			fields = append(fields, subfields...)
@@ -265,10 +275,13 @@ func (b *builder) collapseFormalParam(t llvm.Type, fields []llvm.Value) llvm.Val
 func (b *builder) collapseFormalParamInternal(t llvm.Type, fields []llvm.Value) (llvm.Value, []llvm.Value) {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		flattened := flattenAggregateType(t, "", nil)
+		flattened := b.flattenAggregateType(t, "", nil)
 		if len(flattened) <= maxFieldsPerParam {
 			value := llvm.ConstNull(t)
 			for i, subtyp := range t.StructElementTypes() {
+				if b.targetData.TypeAllocSize(subtyp) == 0 {
+					continue
+				}
 				structField, remaining := b.collapseFormalParamInternal(subtyp, fields)
 				fields = remaining
 				value = b.CreateInsertValue(value, structField, i, "")

compiler/channel.go

@@ -32,8 +32,15 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 
 	// store value-to-send
 	valueType := b.getLLVMType(instr.X.Type())
-	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
-	b.CreateStore(chanValue, valueAlloca)
+	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
+	var valueAlloca, valueAllocaCast, valueAllocaSize llvm.Value
+	if isZeroSize {
+		valueAlloca = llvm.ConstNull(llvm.PointerType(valueType, 0))
+		valueAllocaCast = llvm.ConstNull(b.i8ptrType)
+	} else {
+		valueAlloca, valueAllocaCast, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
+		b.CreateStore(chanValue, valueAlloca)
+	}
 
 	// Allocate blockedlist buffer.
 	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
@@ -46,7 +53,9 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 	// This also works around a bug in CoroSplit, at least in LLVM 8:
 	// https://bugs.llvm.org/show_bug.cgi?id=41742
 	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
-	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+	if !isZeroSize {
+		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+	}
 }
 
 // createChanRecv emits a pseudo chan receive operation. It is lowered to the
@@ -56,7 +65,14 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 	ch := b.getValue(unop.X)
 
 	// Allocate memory to receive into.
-	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
+	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
+	var valueAlloca, valueAllocaCast, valueAllocaSize llvm.Value
+	if isZeroSize {
+		valueAlloca = llvm.ConstNull(llvm.PointerType(valueType, 0))
+		valueAllocaCast = llvm.ConstNull(b.i8ptrType)
+	} else {
+		valueAlloca, valueAllocaCast, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
+	}
 
 	// Allocate blockedlist buffer.
 	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
@@ -64,9 +80,14 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 
 	// Do the receive.
 	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")
-	received := b.CreateLoad(valueAlloca, "chan.received")
+	var received llvm.Value
+	if isZeroSize {
+		received = llvm.ConstNull(valueType)
+	} else {
+		received = b.CreateLoad(valueAlloca, "chan.received")
+		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
+	}
 	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
-	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 
 	if unop.CommaOk {
 		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false))
@@ -79,8 +100,7 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 }
 
 // createChanClose closes the given channel.
-func (b *builder) createChanClose(param ssa.Value) {
-	ch := b.getValue(param)
+func (b *builder) createChanClose(ch llvm.Value) {
 	b.createRuntimeCall("chanClose", []llvm.Value{ch}, "")
 }
 
@@ -117,7 +137,6 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 	// determine the receive buffer size and alignment.
 	recvbufSize := uint64(0)
 	recvbufAlign := 0
-	hasReceives := false
 	var selectStates []llvm.Value
 	chanSelectStateType := b.getLLVMRuntimeType("chanSelectState")
 	for _, state := range expr.States {
@@ -134,7 +153,6 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 			if align := b.targetData.ABITypeAlignment(llvmType); align > recvbufAlign {
 				recvbufAlign = align
 			}
-			hasReceives = true
 		case types.SendOnly:
 			// Store this value in an alloca and put a pointer to this alloca
 			// in the send state.
@@ -151,7 +169,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 
 	// Create a receive buffer, where the received value will be stored.
 	recvbuf := llvm.Undef(b.i8ptrType)
-	if hasReceives {
+	if recvbufSize != 0 {
 		allocaType := llvm.ArrayType(b.ctx.Int8Type(), int(recvbufSize))
 		recvbufAlloca, _, _ := b.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
 		recvbufAlloca.SetAlignment(recvbufAlign)

compiler/compiler_test.go

@@ -0,0 +1,204 @@
+package compiler
+
+import (
+	"flag"
+	"go/types"
+	"io/ioutil"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+	"github.com/tinygo-org/tinygo/goenv"
+	"github.com/tinygo-org/tinygo/loader"
+	"tinygo.org/x/go-llvm"
+)
+
+// Pass -update to go test to update the output of the test files.
+var flagUpdate = flag.Bool("update", false, "update tests based on test output")
+
+type testCase struct {
+	file   string
+	target string
+}
+
+// Basic tests for the compiler. Build some Go files and compare the output with
+// the expected LLVM IR for regression testing.
+func TestCompiler(t *testing.T) {
+	t.Parallel()
+
+	// Check LLVM version.
+	llvmMajor, err := strconv.Atoi(strings.SplitN(llvm.Version, ".", 2)[0])
+	if err != nil {
+		t.Fatal("could not parse LLVM version:", llvm.Version)
+	}
+	if llvmMajor < 11 {
+		// It is likely this version needs to be bumped in the future.
+		// The goal is to at least test the LLVM version that's used by default
+		// in TinyGo and (if possible without too many workarounds) also some
+		// previous versions.
+		t.Skip("compiler tests require LLVM 11 or above, got LLVM ", llvm.Version)
+	}
+
+	tests := []testCase{
+		{"basic.go", ""},
+		{"pointer.go", ""},
+		{"slice.go", ""},
+		{"string.go", ""},
+		{"float.go", ""},
+		{"interface.go", ""},
+		{"func.go", ""},
+		{"pragma.go", ""},
+		{"goroutine.go", "wasm"},
+		{"goroutine.go", "cortex-m-qemu"},
+		{"channel.go", ""},
+		{"intrinsics.go", "cortex-m-qemu"},
+		{"intrinsics.go", "wasm"},
+		{"gc.go", ""},
+	}
+
+	_, minor, err := goenv.GetGorootVersion(goenv.Get("GOROOT"))
+	if err != nil {
+		t.Fatal("could not read Go version:", err)
+	}
+	if minor >= 17 {
+		tests = append(tests, testCase{"go1.17.go", ""})
+	}
+
+	for _, tc := range tests {
+		name := tc.file
+		targetString := "wasm"
+		if tc.target != "" {
+			targetString = tc.target
+			name = tc.file + "-" + tc.target
+		}
+
+		t.Run(name, func(t *testing.T) {
+			options := &compileopts.Options{
+				Target: targetString,
+			}
+			target, err := compileopts.LoadTarget(options)
+			if err != nil {
+				t.Fatal("failed to load target:", err)
+			}
+			config := &compileopts.Config{
+				Options: options,
+				Target:  target,
+			}
+			compilerConfig := &Config{
+				Triple:             config.Triple(),
+				GOOS:               config.GOOS(),
+				GOARCH:             config.GOARCH(),
+				CodeModel:          config.CodeModel(),
+				RelocationModel:    config.RelocationModel(),
+				Scheduler:          config.Scheduler(),
+				FuncImplementation: config.FuncImplementation(),
+				AutomaticStackSize: config.AutomaticStackSize(),
+			}
+			machine, err := NewTargetMachine(compilerConfig)
+			if err != nil {
+				t.Fatal("failed to create target machine:", err)
+			}
+
+			// Load entire program AST into memory.
+			lprogram, err := loader.Load(config, []string{"./testdata/" + tc.file}, config.ClangHeaders, types.Config{
+				Sizes: Sizes(machine),
+			})
+			if err != nil {
+				t.Fatal("failed to create target machine:", err)
+			}
+			err = lprogram.Parse()
+			if err != nil {
+				t.Fatalf("could not parse test case %s: %s", tc.file, err)
+			}
+
+			// Compile AST to IR.
+			program := lprogram.LoadSSA()
+			pkg := lprogram.MainPkg()
+			mod, errs := CompilePackage(tc.file, pkg, program.Package(pkg.Pkg), machine, compilerConfig, false)
+			if errs != nil {
+				for _, err := range errs {
+					t.Error(err)
+				}
+				return
+			}
+
+			err = llvm.VerifyModule(mod, llvm.PrintMessageAction)
+			if err != nil {
+				t.Error(err)
+			}
+
+			// Optimize IR a little.
+			funcPasses := llvm.NewFunctionPassManagerForModule(mod)
+			defer funcPasses.Dispose()
+			funcPasses.AddInstructionCombiningPass()
+			funcPasses.InitializeFunc()
+			for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+				funcPasses.RunFunc(fn)
+			}
+			funcPasses.FinalizeFunc()
+
+			outFilePrefix := tc.file[:len(tc.file)-3]
+			if tc.target != "" {
+				outFilePrefix += "-" + tc.target
+			}
+			outPath := "./testdata/" + outFilePrefix + ".ll"
+
+			// Update test if needed. Do not check the result.
+			if *flagUpdate {
+				err := ioutil.WriteFile(outPath, []byte(mod.String()), 0666)
+				if err != nil {
+					t.Error("failed to write updated output file:", err)
+				}
+				return
+			}
+
+			expected, err := ioutil.ReadFile(outPath)
+			if err != nil {
+				t.Fatal("failed to read golden file:", err)
+			}
+
+			if !fuzzyEqualIR(mod.String(), string(expected)) {
+				t.Errorf("output does not match expected output:\n%s", mod.String())
+			}
+		})
+	}
+}
+
+// fuzzyEqualIR returns true if the two LLVM IR strings passed in are roughly
+// equal. That means, only relevant lines are compared (excluding comments
+// etc.).
+func fuzzyEqualIR(s1, s2 string) bool {
+	lines1 := filterIrrelevantIRLines(strings.Split(s1, "\n"))
+	lines2 := filterIrrelevantIRLines(strings.Split(s2, "\n"))
+	if len(lines1) != len(lines2) {
+		return false
+	}
+	for i, line1 := range lines1 {
+		line2 := lines2[i]
+		if line1 != line2 {
+			return false
+		}
+	}
+
+	return true
+}
+
+// filterIrrelevantIRLines removes lines from the input slice of strings that
+// are not relevant in comparing IR. For example, empty lines and comments are
+// stripped out.
+func filterIrrelevantIRLines(lines []string) []string {
+	var out []string
+	for _, line := range lines {
+		line = strings.Split(line, ";")[0]    // strip out comments/info
+		line = strings.TrimRight(line, "\r ") // drop '\r' on Windows and remove trailing spaces from comments
+		if line == "" {
+			continue
+		}
+		if strings.HasPrefix(line, "source_filename = ") {
+			continue
+		}
+		out = append(out, line)
+	}
+	return out
+}

compiler/defer.go

@@ -14,9 +14,9 @@ package compiler
 //     frames.
 
 import (
-	"github.com/tinygo-org/tinygo/compiler/llvmutil"
-	"github.com/tinygo-org/tinygo/ir"
 	"go/types"
+
+	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -26,9 +26,9 @@ import (
 // calls.
 func (b *builder) deferInitFunc() {
 	// Some setup.
-	b.deferFuncs = make(map[*ir.Function]int)
+	b.deferFuncs = make(map[*ssa.Function]int)
 	b.deferInvokeFuncs = make(map[string]int)
-	b.deferClosureFuncs = make(map[*ir.Function]int)
+	b.deferClosureFuncs = make(map[*ssa.Function]int)
 	b.deferExprFuncs = make(map[ssa.Value]int)
 	b.deferBuiltinFuncs = make(map[ssa.Value]deferBuiltin)
 
@@ -107,13 +107,11 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 
 	} else if callee, ok := instr.Call.Value.(*ssa.Function); ok {
 		// Regular function call.
-		fn := b.ir.GetFunction(callee)
-
-		if _, ok := b.deferFuncs[fn]; !ok {
-			b.deferFuncs[fn] = len(b.allDeferFuncs)
-			b.allDeferFuncs = append(b.allDeferFuncs, fn)
+		if _, ok := b.deferFuncs[callee]; !ok {
+			b.deferFuncs[callee] = len(b.allDeferFuncs)
+			b.allDeferFuncs = append(b.allDeferFuncs, callee)
 		}
-		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[fn]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferFuncs[callee]), false)
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields).
@@ -135,7 +133,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		context := b.CreateExtractValue(closure, 0, "")
 
 		// Get the callback number.
-		fn := b.ir.GetFunction(makeClosure.Fn.(*ssa.Function))
+		fn := makeClosure.Fn.(*ssa.Function)
 		if _, ok := b.deferClosureFuncs[fn]; !ok {
 			b.deferClosureFuncs[fn] = len(b.allDeferFuncs)
 			b.allDeferFuncs = append(b.allDeferFuncs, makeClosure)
@@ -155,19 +153,19 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		valueTypes = append(valueTypes, context.Type())
 
 	} else if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
-		var funcName string
-		switch builtin.Name() {
-		case "close":
-			funcName = "chanClose"
-		default:
-			b.addError(instr.Pos(), "todo: Implement defer for "+builtin.Name())
-			return
+		var argTypes []types.Type
+		var argValues []llvm.Value
+		for _, arg := range instr.Call.Args {
+			argTypes = append(argTypes, arg.Type())
+			argValues = append(argValues, b.getValue(arg))
 		}
 
 		if _, ok := b.deferBuiltinFuncs[instr.Call.Value]; !ok {
 			b.deferBuiltinFuncs[instr.Call.Value] = deferBuiltin{
-				funcName,
-				len(b.allDeferFuncs),
+				callName: builtin.Name(),
+				pos:      builtin.Pos(),
+				argTypes: argTypes,
+				callback: len(b.allDeferFuncs),
 			}
 			b.allDeferFuncs = append(b.allDeferFuncs, instr.Call.Value)
 		}
@@ -176,10 +174,9 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields).
 		values = []llvm.Value{callback, next}
-		for _, param := range instr.Call.Args {
-			llvmParam := b.getValue(param)
-			values = append(values, llvmParam)
-			valueTypes = append(valueTypes, llvmParam.Type())
+		for _, param := range argValues {
+			values = append(values, param)
+			valueTypes = append(valueTypes, param.Type())
 		}
 
 	} else {
@@ -220,10 +217,11 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		// This may be hit a variable number of times, so use a heap allocation.
 		size := b.targetData.TypeAllocSize(deferFrameType)
 		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
-		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "defer.alloc.call")
+		nilPtr := llvm.ConstNull(b.i8ptrType)
+		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, nilPtr}, "defer.alloc.call")
 		alloca = b.CreateBitCast(allocCall, llvm.PointerType(deferFrameType, 0), "defer.alloc")
 	}
-	if b.NeedsStackObjects() {
+	if b.NeedsStackObjects {
 		b.trackPointer(alloca)
 	}
 	b.CreateStore(deferFrame, alloca)
@@ -251,10 +249,10 @@ func (b *builder) createRunDefers() {
 	//     }
 
 	// Create loop.
-	loophead := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.loophead")
-	loop := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.loop")
-	unreachable := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.default")
-	end := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.end")
+	loophead := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.loophead")
+	loop := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.loop")
+	unreachable := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.default")
+	end := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.end")
 	b.CreateBr(loophead)
 
 	// Create loop head:
@@ -286,7 +284,7 @@ func (b *builder) createRunDefers() {
 		// Create switch case, for example:
 		//     case 0:
 		//         // run first deferred call
-		block := b.ctx.AddBasicBlock(b.fn.LLVMFn, "rundefers.callback")
+		block := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.callback")
 		sw.AddCase(llvm.ConstInt(b.uintptrType, uint64(i), false), block)
 		b.SetInsertPointAtEnd(block)
 		switch callback := callback.(type) {
@@ -334,10 +332,10 @@ func (b *builder) createRunDefers() {
 				//Pass context
 				forwardParams = append(forwardParams, context)
 			} else {
-				// Isolate the typecode.
-				typecode := forwardParams[0]
-				forwardParams = forwardParams[1:]
-				fnPtr = b.getInvokePtr(callback, typecode)
+				// Move typecode from the start to the end of the list of
+				// parameters.
+				forwardParams = append(forwardParams[1:], forwardParams[0])
+				fnPtr = b.getInvokeFunction(callback)
 
 				// Add the context parameter. An interface call cannot also be a
 				// closure but we have to supply the parameter anyway for platforms
@@ -350,12 +348,12 @@ func (b *builder) createRunDefers() {
 
 			b.createCall(fnPtr, forwardParams, "")
 
-		case *ir.Function:
+		case *ssa.Function:
 			// Direct call.
 
 			// Get the real defer struct type and cast to it.
 			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
-			for _, param := range callback.Params {
+			for _, param := range getParams(callback.Signature) {
 				valueTypes = append(valueTypes, b.getLLVMType(param.Type()))
 			}
 			deferFrameType := b.ctx.StructType(valueTypes, false)
@@ -364,7 +362,7 @@ func (b *builder) createRunDefers() {
 			// Extract the params from the struct.
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
-			for i := range callback.Params {
+			for i := range getParams(callback.Signature) {
 				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
 				forwardParam := b.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
@@ -372,7 +370,7 @@ func (b *builder) createRunDefers() {
 
 			// Plain TinyGo functions add some extra parameters to implement async functionality and function recievers.
 			// These parameters should not be supplied when calling into an external C/ASM function.
-			if !callback.IsExported() {
+			if !b.getFunctionInfo(callback).exported {
 				// Add the context parameter. We know it is ignored by the receiving
 				// function, but we have to pass one anyway.
 				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
@@ -382,11 +380,11 @@ func (b *builder) createRunDefers() {
 			}
 
 			// Call real function.
-			b.createCall(callback.LLVMFn, forwardParams, "")
+			b.createCall(b.getFunction(callback), forwardParams, "")
 
 		case *ssa.MakeClosure:
 			// Get the real defer struct type and cast to it.
-			fn := b.ir.GetFunction(callback.Fn.(*ssa.Function))
+			fn := callback.Fn.(*ssa.Function)
 			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
 			params := fn.Signature.Params()
 			for i := 0; i < params.Len(); i++ {
@@ -409,7 +407,7 @@ func (b *builder) createRunDefers() {
 			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 
 			// Call deferred function.
-			b.createCall(fn.LLVMFn, forwardParams, "")
+			b.createCall(b.getFunction(fn), forwardParams, "")
 		case *ssa.Builtin:
 			db := b.deferBuiltinFuncs[callback]
 
@@ -426,15 +424,18 @@ func (b *builder) createRunDefers() {
 			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
 
 			// Extract the params from the struct.
-			var forwardParams []llvm.Value
+			var argValues []llvm.Value
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 0; i < params.Len(); i++ {
 				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
 				forwardParam := b.CreateLoad(gep, "param")
-				forwardParams = append(forwardParams, forwardParam)
+				argValues = append(argValues, forwardParam)
 			}
 
-			b.createRuntimeCall(db.funcName, forwardParams, "")
+			_, err := b.createBuiltin(db.argTypes, argValues, db.callName, db.pos)
+			if err != nil {
+				b.diagnostics = append(b.diagnostics, err)
+			}
 		default:
 			panic("unknown deferred function type")
 		}

compiler/errors.go

@@ -3,7 +3,6 @@ package compiler
 // This file contains some utility functions related to error handling.
 
 import (
-	"go/scanner"
 	"go/token"
 	"go/types"
 	"path/filepath"
@@ -14,26 +13,17 @@ import (
 // makeError makes it easy to create an error from a token.Pos with a message.
 func (c *compilerContext) makeError(pos token.Pos, msg string) types.Error {
 	return types.Error{
-		Fset: c.ir.Program.Fset,
+		Fset: c.program.Fset,
 		Pos:  pos,
 		Msg:  msg,
 	}
 }
 
+// addError adds a new compiler diagnostic with the given location and message.
 func (c *compilerContext) addError(pos token.Pos, msg string) {
 	c.diagnostics = append(c.diagnostics, c.makeError(pos, msg))
 }
 
-// errorAt returns an error value at the location of the instruction.
-// The location information may not be complete as it depends on debug
-// information in the IR.
-func errorAt(inst llvm.Value, msg string) scanner.Error {
-	return scanner.Error{
-		Pos: getPosition(inst),
-		Msg: msg,
-	}
-}
-
 // getPosition returns the position information for the given value, as far as
 // it is available.
 func getPosition(val llvm.Value) token.Position {

compiler/func.go

@@ -6,7 +6,6 @@ package compiler
 import (
 	"go/types"
 
-	"github.com/tinygo-org/tinygo/compileopts"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -21,24 +20,23 @@ func (b *builder) createFuncValue(funcPtr, context llvm.Value, sig *types.Signat
 // context.
 func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
 	var funcValueScalar llvm.Value
-	switch c.FuncImplementation() {
-	case compileopts.FuncValueDoubleword:
+	switch c.FuncImplementation {
+	case "doubleword":
 		// Closure is: {context, function pointer}
-		funcValueScalar = funcPtr
-	case compileopts.FuncValueSwitch:
-		sigGlobal := c.getTypeCode(sig)
+		funcValueScalar = llvm.ConstBitCast(funcPtr, c.rawVoidFuncType)
+	case "switch":
 		funcValueWithSignatureGlobalName := funcPtr.Name() + "$withSignature"
 		funcValueWithSignatureGlobal := c.mod.NamedGlobal(funcValueWithSignatureGlobalName)
 		if funcValueWithSignatureGlobal.IsNil() {
 			funcValueWithSignatureType := c.getLLVMRuntimeType("funcValueWithSignature")
 			funcValueWithSignature := llvm.ConstNamedStruct(funcValueWithSignatureType, []llvm.Value{
 				llvm.ConstPtrToInt(funcPtr, c.uintptrType),
-				sigGlobal,
+				c.getFuncSignatureID(sig),
 			})
 			funcValueWithSignatureGlobal = llvm.AddGlobal(c.mod, funcValueWithSignatureType, funcValueWithSignatureGlobalName)
 			funcValueWithSignatureGlobal.SetInitializer(funcValueWithSignature)
 			funcValueWithSignatureGlobal.SetGlobalConstant(true)
-			funcValueWithSignatureGlobal.SetLinkage(llvm.InternalLinkage)
+			funcValueWithSignatureGlobal.SetLinkage(llvm.LinkOnceODRLinkage)
 		}
 		funcValueScalar = llvm.ConstPtrToInt(funcValueWithSignatureGlobal, c.uintptrType)
 	default:
@@ -51,6 +49,19 @@ func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context
 	return funcValue
 }
 
+// getFuncSignatureID returns a new external global for a given signature. This
+// global reference is not real, it is only used during func lowering to assign
+// signature types to functions and will then be removed.
+func (c *compilerContext) getFuncSignatureID(sig *types.Signature) llvm.Value {
+	sigGlobalName := "reflect/types.funcid:" + getTypeCodeName(sig)
+	sigGlobal := c.mod.NamedGlobal(sigGlobalName)
+	if sigGlobal.IsNil() {
+		sigGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), sigGlobalName)
+		sigGlobal.SetGlobalConstant(true)
+	}
+	return sigGlobal
+}
+
 // extractFuncScalar returns some scalar that can be used in comparisons. It is
 // a cheap operation.
 func (b *builder) extractFuncScalar(funcValue llvm.Value) llvm.Value {
@@ -67,12 +78,25 @@ func (b *builder) extractFuncContext(funcValue llvm.Value) llvm.Value {
 // value. This may be an expensive operation.
 func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value) {
 	context = b.CreateExtractValue(funcValue, 0, "")
-	switch b.FuncImplementation() {
-	case compileopts.FuncValueDoubleword:
-		funcPtr = b.CreateExtractValue(funcValue, 1, "")
-	case compileopts.FuncValueSwitch:
+	switch b.FuncImplementation {
+	case "doubleword":
+		bitcast := b.CreateExtractValue(funcValue, 1, "")
+		if !bitcast.IsAConstantExpr().IsNil() && bitcast.Opcode() == llvm.BitCast {
+			funcPtr = bitcast.Operand(0)
+			return
+		}
 		llvmSig := b.getRawFuncType(sig)
-		sigGlobal := b.getTypeCode(sig)
+		funcPtr = b.CreateBitCast(bitcast, llvmSig, "")
+	case "switch":
+		if !funcValue.IsAConstant().IsNil() {
+			// If this is a constant func value, the underlying function is
+			// known and can be returned directly.
+			funcValueWithSignatureGlobal := llvm.ConstExtractValue(funcValue, []uint32{1}).Operand(0)
+			funcPtr = llvm.ConstExtractValue(funcValueWithSignatureGlobal.Initializer(), []uint32{0}).Operand(0)
+			return
+		}
+		llvmSig := b.getRawFuncType(sig)
+		sigGlobal := b.getFuncSignatureID(sig)
 		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
 		funcPtr = b.CreateIntToPtr(funcPtr, llvmSig, "")
 	default:
@@ -83,11 +107,10 @@ func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (f
 
 // getFuncType returns the type of a func value given a signature.
 func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
-	switch c.FuncImplementation() {
-	case compileopts.FuncValueDoubleword:
-		rawPtr := c.getRawFuncType(typ)
-		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false)
-	case compileopts.FuncValueSwitch:
+	switch c.FuncImplementation {
+	case "doubleword":
+		return c.ctx.StructType([]llvm.Type{c.i8ptrType, c.rawVoidFuncType}, false)
+	case "switch":
 		return c.getLLVMRuntimeType("funcValue")
 	default:
 		panic("unimplemented func value variant")
@@ -125,13 +148,13 @@ func (c *compilerContext) getRawFuncType(typ *types.Signature) llvm.Type {
 			// The receiver is not an interface, but a i8* type.
 			recv = c.i8ptrType
 		}
-		for _, info := range expandFormalParamType(recv, "", nil) {
+		for _, info := range c.expandFormalParamType(recv, "", nil) {
 			paramTypes = append(paramTypes, info.llvmType)
 		}
 	}
 	for i := 0; i < typ.Params().Len(); i++ {
 		subType := c.getLLVMType(typ.Params().At(i).Type())
-		for _, info := range expandFormalParamType(subType, "", nil) {
+		for _, info := range c.expandFormalParamType(subType, "", nil) {
 			paramTypes = append(paramTypes, info.llvmType)
 		}
 	}
@@ -149,7 +172,7 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	if len(expr.Bindings) == 0 {
 		panic("unexpected: MakeClosure without bound variables")
 	}
-	f := b.ir.GetFunction(expr.Fn.(*ssa.Function))
+	f := expr.Fn.(*ssa.Function)
 
 	// Collect all bound variables.
 	boundVars := make([]llvm.Value, len(expr.Bindings))
@@ -164,5 +187,5 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	context := b.emitPointerPack(boundVars)
 
 	// Create the closure.
-	return b.createFuncValue(f.LLVMFn, context, f.Signature), nil
+	return b.createFuncValue(b.getFunction(f), context, f.Signature), nil
 }

compiler/goroutine.go

@@ -5,34 +5,129 @@ package compiler
 
 import (
 	"go/token"
+	"go/types"
 
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
+	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
-// createGoInstruction starts a new goroutine with the provided function pointer
-// and parameters.
-// In general, you should pass all regular parameters plus the context parameter.
-// There is one exception: the task-based scheduler needs to have the function
-// pointer passed in as a parameter too in addition to the context.
-//
-// Because a go statement doesn't return anything, return undef.
-func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, prefix string, pos token.Pos) llvm.Value {
+// createGo emits code to start a new goroutine.
+func (b *builder) createGo(instr *ssa.Go) {
+	// Get all function parameters to pass to the goroutine.
+	var params []llvm.Value
+	for _, param := range instr.Call.Args {
+		params = append(params, b.getValue(param))
+	}
+
+	var prefix string
+	var funcPtr llvm.Value
+	hasContext := false
+	if callee := instr.Call.StaticCallee(); callee != nil {
+		// Static callee is known. This makes it easier to start a new
+		// goroutine.
+		var context llvm.Value
+		switch value := instr.Call.Value.(type) {
+		case *ssa.Function:
+			// Goroutine call is regular function call. No context is necessary.
+			if b.Scheduler == "coroutines" {
+				// The context parameter is assumed to be always present in the
+				// coroutines scheduler.
+				context = llvm.Undef(b.i8ptrType)
+			}
+		case *ssa.MakeClosure:
+			// A goroutine call on a func value, but the callee is trivial to find. For
+			// example: immediately applied functions.
+			funcValue := b.getValue(value)
+			context = b.extractFuncContext(funcValue)
+		default:
+			panic("StaticCallee returned an unexpected value")
+		}
+		if !context.IsNil() {
+			params = append(params, context) // context parameter
+			hasContext = true
+		}
+		funcPtr = b.getFunction(callee)
+	} else if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
+		// We cheat. None of the builtins do any long or blocking operation, so
+		// we might as well run these builtins right away without the program
+		// noticing the difference.
+		// Possible exceptions:
+		//   - copy: this is a possibly long operation, but not a blocking
+		//     operation. Semantically it makes no difference to run it right
+		//     away (not in a goroutine). However, in practice it makes no sense
+		//     to run copy in a goroutine as there is no way to (safely) know
+		//     when it is finished.
+		//   - panic: the error message would appear in the parent goroutine.
+		//     But because `go panic("err")` would halt the program anyway
+		//     (there is no recover), panicking right away would give the same
+		//     behavior as creating a goroutine, switching the scheduler to that
+		//     goroutine, and panicking there. So this optimization seems
+		//     correct.
+		//   - recover: because it runs in a new goroutine, it is never a
+		//     deferred function. Thus this is a no-op.
+		if builtin.Name() == "recover" {
+			// This is a no-op, even in a deferred function:
+			//   go recover()
+			return
+		}
+		var argTypes []types.Type
+		var argValues []llvm.Value
+		for _, arg := range instr.Call.Args {
+			argTypes = append(argTypes, arg.Type())
+			argValues = append(argValues, b.getValue(arg))
+		}
+		b.createBuiltin(argTypes, argValues, builtin.Name(), instr.Pos())
+		return
+	} else if instr.Call.IsInvoke() {
+		// This is a method call on an interface value.
+		itf := b.getValue(instr.Call.Value)
+		itfTypeCode := b.CreateExtractValue(itf, 0, "")
+		itfValue := b.CreateExtractValue(itf, 1, "")
+		funcPtr = b.getInvokeFunction(&instr.Call)
+		params = append([]llvm.Value{itfValue}, params...) // start with receiver
+		params = append(params, itfTypeCode)               // end with typecode
+	} else {
+		// This is a function pointer.
+		// At the moment, two extra params are passed to the newly started
+		// goroutine:
+		//   * The function context, for closures.
+		//   * The function pointer (for tasks).
+		var context llvm.Value
+		funcPtr, context = b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
+		params = append(params, context) // context parameter
+		hasContext = true
+		switch b.Scheduler {
+		case "none", "coroutines":
+			// There are no additional parameters needed for the goroutine start operation.
+		case "tasks":
+			// Add the function pointer as a parameter to start the goroutine.
+			params = append(params, funcPtr)
+		default:
+			panic("unknown scheduler type")
+		}
+		prefix = b.fn.RelString(nil)
+	}
+
 	paramBundle := b.emitPointerPack(params)
 	var callee, stackSize llvm.Value
-	switch b.Scheduler() {
+	switch b.Scheduler {
 	case "none", "tasks":
-		callee = b.createGoroutineStartWrapper(funcPtr, prefix, pos)
-		if b.AutomaticStackSize() {
+		callee = b.createGoroutineStartWrapper(funcPtr, prefix, hasContext, instr.Pos())
+		if b.AutomaticStackSize {
 			// The stack size is not known until after linking. Call a dummy
 			// function that will be replaced with a load from a special ELF
 			// section that contains the stack size (and is modified after
 			// linking).
-			stackSize = b.createCall(b.mod.NamedFunction("internal/task.getGoroutineStackSize"), []llvm.Value{callee, llvm.Undef(b.i8ptrType), llvm.Undef(b.i8ptrType)}, "stacksize")
+			stackSizeFn := b.getFunction(b.program.ImportedPackage("internal/task").Members["getGoroutineStackSize"].(*ssa.Function))
+			stackSize = b.createCall(stackSizeFn, []llvm.Value{callee, llvm.Undef(b.i8ptrType), llvm.Undef(b.i8ptrType)}, "stacksize")
 		} else {
 			// The stack size is fixed at compile time. By emitting it here as a
 			// constant, it can be optimized.
-			stackSize = llvm.ConstInt(b.uintptrType, b.Target.DefaultStackSize, false)
+			if b.Scheduler == "tasks" && b.DefaultStackSize == 0 {
+				b.addError(instr.Pos(), "default stack size for goroutines is not set")
+			}
+			stackSize = llvm.ConstInt(b.uintptrType, b.DefaultStackSize, false)
 		}
 	case "coroutines":
 		callee = b.CreatePtrToInt(funcPtr, b.uintptrType, "")
@@ -42,8 +137,8 @@ func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, p
 	default:
 		panic("unreachable")
 	}
-	b.createCall(b.mod.NamedFunction("internal/task.start"), []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
-	return llvm.Undef(funcPtr.Type().ElementType().ReturnType())
+	start := b.getFunction(b.program.ImportedPackage("internal/task").Members["start"].(*ssa.Function))
+	b.createCall(start, []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
 }
 
 // createGoroutineStartWrapper creates a wrapper for the task-based
@@ -64,7 +159,12 @@ func (b *builder) createGoInstruction(funcPtr llvm.Value, params []llvm.Value, p
 // allows a single (pointer) argument to the newly started goroutine. Also, it
 // ignores the return value because newly started goroutines do not have a
 // return value.
-func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, pos token.Pos) llvm.Value {
+//
+// The hasContext parameter indicates whether the context parameter (the second
+// to last parameter of the function) is used for this wrapper. If hasContext is
+// false, the parameter bundle is assumed to have no context parameter and undef
+// is passed instead.
+func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, hasContext bool, pos token.Pos) llvm.Value {
 	var wrapper llvm.Value
 
 	builder := c.ctx.NewBuilder()
@@ -81,14 +181,15 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// Create the wrapper.
 		wrapperType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.i8ptrType}, false)
 		wrapper = llvm.AddFunction(c.mod, name+"$gowrapper", wrapperType)
-		wrapper.SetLinkage(llvm.InternalLinkage)
+		c.addStandardAttributes(wrapper)
+		wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
 		wrapper.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", name))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		builder.SetInsertPointAtEnd(entry)
 
-		if c.Debug() {
-			pos := c.ir.Program.Fset.Position(pos)
+		if c.Debug {
+			pos := c.program.Fset.Position(pos)
 			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
 				File:       c.getDIFile(pos.Filename),
 				Parameters: nil, // do not show parameters in debugger
@@ -111,8 +212,15 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 
 		// Create the list of params for the call.
 		paramTypes := fn.Type().ElementType().ParamTypes()
-		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes[:len(paramTypes)-1])
-		params = append(params, llvm.Undef(c.i8ptrType))
+		paramTypes = paramTypes[:len(paramTypes)-1] // strip parentHandle parameter
+		if !hasContext {
+			paramTypes = paramTypes[:len(paramTypes)-1] // strip context parameter
+		}
+		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)
+		if !hasContext {
+			params = append(params, llvm.Undef(c.i8ptrType)) // add dummy context parameter
+		}
+		params = append(params, llvm.Undef(c.i8ptrType)) // add dummy parentHandle parameter
 
 		// Create the call.
 		builder.CreateCall(fn, params, "")
@@ -138,14 +246,15 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// Create the wrapper.
 		wrapperType := llvm.FunctionType(c.ctx.VoidType(), []llvm.Type{c.i8ptrType}, false)
 		wrapper = llvm.AddFunction(c.mod, prefix+".gowrapper", wrapperType)
-		wrapper.SetLinkage(llvm.InternalLinkage)
+		c.addStandardAttributes(wrapper)
+		wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
 		wrapper.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", ""))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		builder.SetInsertPointAtEnd(entry)
 
-		if c.Debug() {
-			pos := c.ir.Program.Fset.Position(pos)
+		if c.Debug {
+			pos := c.program.Fset.Position(pos)
 			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
 				File:       c.getDIFile(pos.Filename),
 				Parameters: nil, // do not show parameters in debugger
@@ -174,8 +283,11 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// Get the function pointer.
 		fnPtr := params[len(params)-1]
 
-		// Ignore the last param, which isn't used anymore.
-		// TODO: avoid this extra "parent handle" parameter in most functions.
+		// The last parameter in the packed object has somewhat of a dual role.
+		// Inside the parameter bundle it's the function pointer, stored right
+		// after the context pointer. But in the IR call instruction, it's the
+		// parentHandle function that's always undef outside of the coroutines
+		// scheduler. Thus, make the parameter undef here.
 		params[len(params)-1] = llvm.Undef(c.i8ptrType)
 
 		// Create the call.

compiler/inlineasm.go

@@ -72,7 +72,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 	args := []llvm.Value{}
 	constraints := []string{}
 	hasOutput := false
-	asmString = regexp.MustCompile("\\{\\}").ReplaceAllStringFunc(asmString, func(s string) string {
+	asmString = regexp.MustCompile(`\{\}`).ReplaceAllStringFunc(asmString, func(s string) string {
 		hasOutput = true
 		return "$0"
 	})
@@ -80,7 +80,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 		constraints = append(constraints, "=&r")
 		registerNumbers[""] = 0
 	}
-	asmString = regexp.MustCompile("\\{[a-zA-Z]+\\}").ReplaceAllStringFunc(asmString, func(s string) 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]

compiler/interface.go

@@ -11,7 +11,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/tinygo-org/tinygo/ir"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -25,16 +24,7 @@ import (
 func (b *builder) createMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) llvm.Value {
 	itfValue := b.emitPointerPack([]llvm.Value{val})
 	itfTypeCodeGlobal := b.getTypeCode(typ)
-	itfMethodSetGlobal := b.getTypeMethodSet(typ)
-	itfConcreteTypeGlobal := b.mod.NamedGlobal("typeInInterface:" + itfTypeCodeGlobal.Name())
-	if itfConcreteTypeGlobal.IsNil() {
-		typeInInterface := b.getLLVMRuntimeType("typeInInterface")
-		itfConcreteTypeGlobal = llvm.AddGlobal(b.mod, typeInInterface, "typeInInterface:"+itfTypeCodeGlobal.Name())
-		itfConcreteTypeGlobal.SetInitializer(llvm.ConstNamedStruct(typeInInterface, []llvm.Value{itfTypeCodeGlobal, itfMethodSetGlobal}))
-		itfConcreteTypeGlobal.SetGlobalConstant(true)
-		itfConcreteTypeGlobal.SetLinkage(llvm.PrivateLinkage)
-	}
-	itfTypeCode := b.CreatePtrToInt(itfConcreteTypeGlobal, b.uintptrType, "")
+	itfTypeCode := b.CreatePtrToInt(itfTypeCodeGlobal, b.uintptrType, "")
 	itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
 	itf = b.CreateInsertValue(itf, itfTypeCode, 0, "")
 	itf = b.CreateInsertValue(itf, itfValue, 1, "")
@@ -55,6 +45,9 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		// reflect lowering simpler.
 		var references llvm.Value
 		var length int64
+		var methodSet llvm.Value
+		var ptrTo llvm.Value
+		var typeAssert llvm.Value
 		switch typ := typ.(type) {
 		case *types.Named:
 			references = c.getTypeCode(typ.Underlying())
@@ -71,18 +64,38 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 			// Take a pointer to the typecodeID of the first field (if it exists).
 			structGlobal := c.makeStructTypeFields(typ)
 			references = llvm.ConstBitCast(structGlobal, global.Type())
+		case *types.Interface:
+			methodSetGlobal := c.getInterfaceMethodSet(typ)
+			references = llvm.ConstBitCast(methodSetGlobal, global.Type())
 		}
+		if _, ok := typ.Underlying().(*types.Interface); !ok {
+			methodSet = c.getTypeMethodSet(typ)
+		} else {
+			typeAssert = c.getInterfaceImplementsFunc(typ)
+			typeAssert = llvm.ConstPtrToInt(typeAssert, c.uintptrType)
+		}
+		if _, ok := typ.Underlying().(*types.Pointer); !ok {
+			ptrTo = c.getTypeCode(types.NewPointer(typ))
+		}
+		globalValue := llvm.ConstNull(global.Type().ElementType())
 		if !references.IsNil() {
-			// Set the 'references' field of the runtime.typecodeID struct.
-			globalValue := llvm.ConstNull(global.Type().ElementType())
 			globalValue = llvm.ConstInsertValue(globalValue, references, []uint32{0})
-			if length != 0 {
-				lengthValue := llvm.ConstInt(c.uintptrType, uint64(length), false)
-				globalValue = llvm.ConstInsertValue(globalValue, lengthValue, []uint32{1})
-			}
-			global.SetInitializer(globalValue)
-			global.SetLinkage(llvm.PrivateLinkage)
 		}
+		if length != 0 {
+			lengthValue := llvm.ConstInt(c.uintptrType, uint64(length), false)
+			globalValue = llvm.ConstInsertValue(globalValue, lengthValue, []uint32{1})
+		}
+		if !methodSet.IsNil() {
+			globalValue = llvm.ConstInsertValue(globalValue, methodSet, []uint32{2})
+		}
+		if !ptrTo.IsNil() {
+			globalValue = llvm.ConstInsertValue(globalValue, ptrTo, []uint32{3})
+		}
+		if !typeAssert.IsNil() {
+			globalValue = llvm.ConstInsertValue(globalValue, typeAssert, []uint32{4})
+		}
+		global.SetInitializer(globalValue)
+		global.SetLinkage(llvm.LinkOnceODRLinkage)
 		global.SetGlobalConstant(true)
 	}
 	return global
@@ -104,8 +117,8 @@ func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
 		fieldName.SetLinkage(llvm.PrivateLinkage)
 		fieldName.SetUnnamedAddr(true)
 		fieldName = llvm.ConstGEP(fieldName, []llvm.Value{
-			llvm.ConstInt(llvm.Int32Type(), 0, false),
-			llvm.ConstInt(llvm.Int32Type(), 0, false),
+			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
 		})
 		fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldName, []uint32{1})
 		if typ.Tag(i) != "" {
@@ -113,8 +126,8 @@ func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
 			fieldTag.SetLinkage(llvm.PrivateLinkage)
 			fieldTag.SetUnnamedAddr(true)
 			fieldTag = llvm.ConstGEP(fieldTag, []llvm.Value{
-				llvm.ConstInt(llvm.Int32Type(), 0, false),
-				llvm.ConstInt(llvm.Int32Type(), 0, false),
+				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
 			})
 			fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldTag, []uint32{2})
 		}
@@ -187,7 +200,11 @@ func getTypeCodeName(t types.Type) string {
 	case *types.Interface:
 		methods := make([]string, t.NumMethods())
 		for i := 0; i < t.NumMethods(); i++ {
-			methods[i] = getTypeCodeName(t.Method(i).Type())
+			name := t.Method(i).Name()
+			if !token.IsExported(name) {
+				name = t.Method(i).Pkg().Path() + "." + name
+			}
+			methods[i] = name + ":" + getTypeCodeName(t.Method(i).Type())
 		}
 		return "interface:" + "{" + strings.Join(methods, ",") + "}"
 	case *types.Map:
@@ -236,7 +253,7 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 		return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 	}
 
-	ms := c.ir.Program.MethodSets.MethodSet(typ)
+	ms := c.program.MethodSets.MethodSet(typ)
 	if ms.Len() == 0 {
 		// no methods, so can leave that one out
 		return llvm.ConstPointerNull(llvm.PointerType(c.getLLVMRuntimeType("interfaceMethodInfo"), 0))
@@ -247,15 +264,16 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 	for i := 0; i < ms.Len(); i++ {
 		method := ms.At(i)
 		signatureGlobal := c.getMethodSignature(method.Obj().(*types.Func))
-		f := c.ir.GetFunction(c.ir.Program.MethodValue(method))
-		if f.LLVMFn.IsNil() {
+		fn := c.program.MethodValue(method)
+		llvmFn := c.getFunction(fn)
+		if llvmFn.IsNil() {
 			// compiler error, so panic
-			panic("cannot find function: " + f.LinkName())
+			panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
 		}
-		fn := c.getInterfaceInvokeWrapper(f)
+		wrapper := c.getInterfaceInvokeWrapper(fn, llvmFn)
 		methodInfo := llvm.ConstNamedStruct(interfaceMethodInfoType, []llvm.Value{
 			signatureGlobal,
-			llvm.ConstPtrToInt(fn, c.uintptrType),
+			llvm.ConstPtrToInt(wrapper, c.uintptrType),
 		})
 		methods[i] = methodInfo
 	}
@@ -264,7 +282,7 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 	global = llvm.AddGlobal(c.mod, arrayType, typ.String()+"$methodset")
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.PrivateLinkage)
+	global.SetLinkage(llvm.LinkOnceODRLinkage)
 	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 }
 
@@ -295,19 +313,37 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 	global = llvm.AddGlobal(c.mod, value.Type(), name+"$interface")
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.PrivateLinkage)
+	global.SetLinkage(llvm.LinkOnceODRLinkage)
 	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 }
 
+// getMethodSignatureName returns a unique name (that can be used as the name of
+// a global) for the given method.
+func (c *compilerContext) getMethodSignatureName(method *types.Func) string {
+	signature := methodSignature(method)
+	var globalName string
+	if token.IsExported(method.Name()) {
+		globalName = "reflect/methods." + signature
+	} else {
+		globalName = method.Type().(*types.Signature).Recv().Pkg().Path() + ".$methods." + signature
+	}
+	return globalName
+}
+
 // getMethodSignature returns a global variable which is a reference to an
 // external *i8 indicating the indicating the signature of this method. It is
 // used during the interface lowering pass.
 func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
-	signature := ir.MethodSignature(method)
-	signatureGlobal := c.mod.NamedGlobal("func " + signature)
+	globalName := c.getMethodSignatureName(method)
+	signatureGlobal := c.mod.NamedGlobal(globalName)
 	if signatureGlobal.IsNil() {
-		signatureGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), "func "+signature)
+		// TODO: put something useful in these globals, such as the method
+		// signature. Useful to one day implement reflect.Value.Method(n).
+		signatureGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), globalName)
+		signatureGlobal.SetInitializer(llvm.ConstInt(c.ctx.Int8Type(), 0, false))
+		signatureGlobal.SetLinkage(llvm.LinkOnceODRLinkage)
 		signatureGlobal.SetGlobalConstant(true)
+		signatureGlobal.SetAlignment(1)
 	}
 	return signatureGlobal
 }
@@ -327,21 +363,28 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	commaOk := llvm.Value{}
 	if _, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
 		// Type assert on interface type.
-		// This pseudo call will be lowered in the interface lowering pass to a
-		// real call which checks whether the provided typecode is any of the
-		// concrete types that implements this interface.
+		// This is a call to an interface type assert function.
+		// The interface lowering pass will define this function by filling it
+		// with a type switch over all concrete types that implement this
+		// interface, and returning whether it's one of the matched types.
 		// This is very different from how interface asserts are implemented in
 		// the main Go compiler, where the runtime checks whether the type
 		// implements each method of the interface. See:
 		// https://research.swtch.com/interfaces
-		methodSet := b.getInterfaceMethodSet(expr.AssertedType)
-		commaOk = b.createRuntimeCall("interfaceImplements", []llvm.Value{actualTypeNum, methodSet}, "")
+		fn := b.getInterfaceImplementsFunc(expr.AssertedType)
+		commaOk = b.CreateCall(fn, []llvm.Value{actualTypeNum}, "")
 
 	} else {
+		globalName := "reflect/types.typeid:" + getTypeCodeName(expr.AssertedType)
+		assertedTypeCodeGlobal := b.mod.NamedGlobal(globalName)
+		if assertedTypeCodeGlobal.IsNil() {
+			// Create a new typecode global.
+			assertedTypeCodeGlobal = llvm.AddGlobal(b.mod, b.ctx.Int8Type(), globalName)
+			assertedTypeCodeGlobal.SetGlobalConstant(true)
+		}
 		// Type assert on concrete type.
 		// Call runtime.typeAssert, which will be lowered to a simple icmp or
 		// const false in the interface lowering pass.
-		assertedTypeCodeGlobal := b.getTypeCode(expr.AssertedType)
 		commaOk = b.createRuntimeCall("typeAssert", []llvm.Value{actualTypeNum, assertedTypeCodeGlobal}, "typecode")
 	}
 
@@ -357,8 +400,8 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	// value.
 
 	prevBlock := b.GetInsertBlock()
-	okBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.ok")
-	nextBlock := b.ctx.AddBasicBlock(b.fn.LLVMFn, "typeassert.next")
+	okBlock := b.ctx.AddBasicBlock(b.llvmFn, "typeassert.ok")
+	nextBlock := b.ctx.AddBasicBlock(b.llvmFn, "typeassert.next")
 	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
 	b.CreateCondBr(commaOk, okBlock, nextBlock)
 
@@ -396,39 +439,52 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	}
 }
 
-// getInvokePtr creates an interface function pointer lookup for the specified invoke instruction, using a specified typecode.
-func (b *builder) getInvokePtr(instr *ssa.CallCommon, typecode llvm.Value) llvm.Value {
-	llvmFnType := b.getRawFuncType(instr.Method.Type().(*types.Signature))
-	values := []llvm.Value{
-		typecode,
-		b.getInterfaceMethodSet(instr.Value.Type()),
-		b.getMethodSignature(instr.Method),
+// getMethodsString returns a string to be used in the "tinygo-methods" string
+// attribute for interface functions.
+func (c *compilerContext) getMethodsString(itf *types.Interface) string {
+	methods := make([]string, itf.NumMethods())
+	for i := range methods {
+		methods[i] = c.getMethodSignatureName(itf.Method(i))
 	}
-	fn := b.createRuntimeCall("interfaceMethod", values, "invoke.func")
-	return b.CreateIntToPtr(fn, llvmFnType, "invoke.func.cast")
+	return strings.Join(methods, "; ")
 }
 
-// getInvokeCall creates and returns the function pointer and parameters of an
-// interface call.
-func (b *builder) getInvokeCall(instr *ssa.CallCommon) (llvm.Value, []llvm.Value) {
-	// Call an interface method with dynamic dispatch.
-	itf := b.getValue(instr.Value) // interface
-
-	typecode := b.CreateExtractValue(itf, 0, "invoke.typecode")
-	fnCast := b.getInvokePtr(instr, typecode)
-	receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")
-
-	args := []llvm.Value{receiverValue}
-	for _, arg := range instr.Args {
-		args = append(args, b.getValue(arg))
+// getInterfaceImplementsfunc returns a declared function that works as a type
+// switch. The interface lowering pass will define this function.
+func (c *compilerContext) getInterfaceImplementsFunc(assertedType types.Type) llvm.Value {
+	fnName := getTypeCodeName(assertedType.Underlying()) + ".$typeassert"
+	llvmFn := c.mod.NamedFunction(fnName)
+	if llvmFn.IsNil() {
+		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.uintptrType}, false)
+		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
+		c.addStandardDeclaredAttributes(llvmFn)
+		methods := c.getMethodsString(assertedType.Underlying().(*types.Interface))
+		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-methods", methods))
 	}
-	// Add the context parameter. An interface call never takes a context but we
-	// have to supply the parameter anyway.
-	args = append(args, llvm.Undef(b.i8ptrType))
-	// Add the parent goroutine handle.
-	args = append(args, llvm.Undef(b.i8ptrType))
+	return llvmFn
+}
 
-	return fnCast, args
+// getInvokeFunction returns the thunk to call the given interface method. The
+// thunk is declared, not defined: it will be defined by the interface lowering
+// pass.
+func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
+	fnName := getTypeCodeName(instr.Value.Type().Underlying()) + "." + instr.Method.Name() + "$invoke"
+	llvmFn := c.mod.NamedFunction(fnName)
+	if llvmFn.IsNil() {
+		sig := instr.Method.Type().(*types.Signature)
+		var paramTuple []*types.Var
+		for i := 0; i < sig.Params().Len(); i++ {
+			paramTuple = append(paramTuple, sig.Params().At(i))
+		}
+		paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.Uintptr]))
+		llvmFnType := c.getRawFuncType(types.NewSignature(sig.Recv(), types.NewTuple(paramTuple...), sig.Results(), false)).ElementType()
+		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
+		c.addStandardDeclaredAttributes(llvmFn)
+		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-invoke", c.getMethodSignatureName(instr.Method)))
+		methods := c.getMethodsString(instr.Value.Type().Underlying().(*types.Interface))
+		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-methods", methods))
+	}
+	return llvmFn
 }
 
 // getInterfaceInvokeWrapper returns a wrapper for the given method so it can be
@@ -436,8 +492,8 @@ func (b *builder) getInvokeCall(instr *ssa.CallCommon) (llvm.Value, []llvm.Value
 // value, dereferences or unpacks it if necessary, and calls the real method.
 // If the method to wrap has a pointer receiver, no wrapping is necessary and
 // the function is returned directly.
-func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
-	wrapperName := f.LinkName() + "$invoke"
+func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llvm.Value) llvm.Value {
+	wrapperName := llvmFn.Name() + "$invoke"
 	wrapper := c.mod.NamedFunction(wrapperName)
 	if !wrapper.IsNil() {
 		// Wrapper already created. Return it directly.
@@ -445,9 +501,9 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	}
 
 	// Get the expanded receiver type.
-	receiverType := c.getLLVMType(f.Params[0].Type())
+	receiverType := c.getLLVMType(fn.Signature.Recv().Type())
 	var expandedReceiverType []llvm.Type
-	for _, info := range expandFormalParamType(receiverType, "", nil) {
+	for _, info := range c.expandFormalParamType(receiverType, "", nil) {
 		expandedReceiverType = append(expandedReceiverType, info.llvmType)
 	}
 
@@ -457,17 +513,18 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 		// Casting a function signature to a different signature and calling it
 		// with a receiver pointer bitcasted to *i8 (as done in calls on an
 		// interface) is hopefully a safe (defined) operation.
-		return f.LLVMFn
+		return llvmFn
 	}
 
 	// create wrapper function
-	fnType := f.LLVMFn.Type().ElementType()
+	fnType := llvmFn.Type().ElementType()
 	paramTypes := append([]llvm.Type{c.i8ptrType}, fnType.ParamTypes()[len(expandedReceiverType):]...)
 	wrapFnType := llvm.FunctionType(fnType.ReturnType(), paramTypes, false)
 	wrapper = llvm.AddFunction(c.mod, wrapperName, wrapFnType)
+	c.addStandardAttributes(wrapper)
 	wrapper.LastParam().SetName("parentHandle")
 
-	wrapper.SetLinkage(llvm.InternalLinkage)
+	wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
 	wrapper.SetUnnamedAddr(true)
 
 	// Create a new builder just to create this wrapper.
@@ -478,9 +535,9 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 	defer b.Builder.Dispose()
 
 	// add debug info if needed
-	if c.Debug() {
-		pos := c.ir.Program.Fset.Position(f.Pos())
-		difunc := c.attachDebugInfoRaw(f, wrapper, "$invoke", pos.Filename, pos.Line)
+	if c.Debug {
+		pos := c.program.Fset.Position(fn.Pos())
+		difunc := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
 		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 	}
 
@@ -490,13 +547,60 @@ func (c *compilerContext) getInterfaceInvokeWrapper(f *ir.Function) llvm.Value {
 
 	receiverValue := b.emitPointerUnpack(wrapper.Param(0), []llvm.Type{receiverType})[0]
 	params := append(b.expandFormalParam(receiverValue), wrapper.Params()[1:]...)
-	if f.LLVMFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
-		b.CreateCall(f.LLVMFn, params, "")
+	if llvmFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
+		b.CreateCall(llvmFn, params, "")
 		b.CreateRetVoid()
 	} else {
-		ret := b.CreateCall(f.LLVMFn, params, "ret")
+		ret := b.CreateCall(llvmFn, params, "ret")
 		b.CreateRet(ret)
 	}
 
 	return wrapper
 }
+
+// methodSignature creates a readable version of a method signature (including
+// the function name, excluding the receiver name). This string is used
+// internally to match interfaces and to call the correct method on an
+// interface. Examples:
+//
+//     String() string
+//     Read([]byte) (int, error)
+func methodSignature(method *types.Func) string {
+	return method.Name() + signature(method.Type().(*types.Signature))
+}
+
+// Make a readable version of a function (pointer) signature.
+// Examples:
+//
+//     () string
+//     (string, int) (int, error)
+func signature(sig *types.Signature) string {
+	s := ""
+	if sig.Params().Len() == 0 {
+		s += "()"
+	} else {
+		s += "("
+		for i := 0; i < sig.Params().Len(); i++ {
+			if i > 0 {
+				s += ", "
+			}
+			s += sig.Params().At(i).Type().String()
+		}
+		s += ")"
+	}
+	if sig.Results().Len() == 0 {
+		// keep as-is
+	} else if sig.Results().Len() == 1 {
+		s += " " + sig.Results().At(0).Type().String()
+	} else {
+		s += " ("
+		for i := 0; i < sig.Results().Len(); i++ {
+			if i > 0 {
+				s += ", "
+			}
+			s += sig.Results().At(i).Type().String()
+		}
+		s += ")"
+	}
+	return s
+}

compiler/interrupt.go

@@ -36,27 +36,27 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 		// Fall back to a generic error.
 		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt function must be constant")
 	}
+	funcRawPtr, funcContext := b.decodeFuncValue(funcValue, nil)
+	funcPtr := llvm.ConstPtrToInt(funcRawPtr, b.uintptrType)
 
 	// Create a new global of type runtime/interrupt.handle. Globals of this
 	// type are lowered in the interrupt lowering pass.
-	globalType := b.ir.Program.ImportedPackage("runtime/interrupt").Type("handle").Type()
+	globalType := b.program.ImportedPackage("runtime/interrupt").Type("handle").Type()
 	globalLLVMType := b.getLLVMType(globalType)
-	globalName := "runtime/interrupt.$interrupt" + strconv.FormatInt(id.Int64(), 10)
-	if global := b.mod.NamedGlobal(globalName); !global.IsNil() {
-		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt redeclared in this program")
-	}
+	globalName := b.fn.Package().Pkg.Path() + "$interrupt" + strconv.FormatInt(id.Int64(), 10)
 	global := llvm.AddGlobal(b.mod, globalLLVMType, globalName)
-	global.SetLinkage(llvm.PrivateLinkage)
+	global.SetVisibility(llvm.HiddenVisibility)
 	global.SetGlobalConstant(true)
 	global.SetUnnamedAddr(true)
 	initializer := llvm.ConstNull(globalLLVMType)
-	initializer = llvm.ConstInsertValue(initializer, funcValue, []uint32{0})
-	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(b.intType, uint64(id.Int64()), true), []uint32{1, 0})
+	initializer = llvm.ConstInsertValue(initializer, funcContext, []uint32{0})
+	initializer = llvm.ConstInsertValue(initializer, funcPtr, []uint32{1})
+	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(b.intType, uint64(id.Int64()), true), []uint32{2, 0})
 	global.SetInitializer(initializer)
 
 	// Add debug info to the interrupt global.
-	if b.Debug() {
-		pos := b.ir.Program.Fset.Position(instr.Pos())
+	if b.Debug {
+		pos := b.program.Fset.Position(instr.Pos())
 		diglobal := b.dibuilder.CreateGlobalVariableExpression(b.getDIFile(pos.Filename), llvm.DIGlobalVariableExpression{
 			Name:        "interrupt" + strconv.FormatInt(id.Int64(), 10),
 			LinkageName: globalName,
@@ -79,7 +79,7 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	// PLIC where each interrupt must be enabled using the interrupt number, and
 	// thus keeps the Interrupt object alive.
 	// This call is removed during interrupt lowering.
-	if strings.HasPrefix(b.Triple(), "avr") {
+	if strings.HasPrefix(b.Triple, "avr") {
 		useFn := b.mod.NamedFunction("runtime/interrupt.use")
 		if useFn.IsNil() {
 			useFnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{interrupt.Type()}, false)

compiler/intrinsics.go

@@ -48,3 +48,57 @@ func (b *builder) createMemoryZeroCall(args []ssa.Value) (llvm.Value, error) {
 	b.CreateCall(llvmFn, params, "")
 	return llvm.Value{}, nil
 }
+
+var mathToLLVMMapping = map[string]string{
+	"math.Sqrt":  "llvm.sqrt.f64",
+	"math.Floor": "llvm.floor.f64",
+	"math.Ceil":  "llvm.ceil.f64",
+	"math.Trunc": "llvm.trunc.f64",
+}
+
+// createMathOp tries to lower the given call as a LLVM math intrinsic, if
+// possible. It returns the call result if possible, and a boolean whether it
+// succeeded. If it doesn't succeed, the architecture doesn't support the given
+// intrinsic.
+func (b *builder) createMathOp(call *ssa.CallCommon) (llvm.Value, bool) {
+	// Check whether this intrinsic is supported on the given GOARCH.
+	// If it is unsupported, this can have two reasons:
+	//
+	//  1. LLVM can expand the intrinsic inline (using float instructions), but
+	//     the result doesn't pass the tests of the math package.
+	//  2. LLVM cannot expand the intrinsic inline, will therefore lower it as a
+	//     libm function call, but the libm function call also fails the math
+	//     package tests.
+	//
+	// Whatever the implementation, it must pass the tests in the math package
+	// so unfortunately only the below intrinsic+architecture combinations are
+	// supported.
+	name := call.StaticCallee().RelString(nil)
+	switch name {
+	case "math.Ceil", "math.Floor", "math.Trunc":
+		if b.GOARCH != "wasm" && b.GOARCH != "arm64" {
+			return llvm.Value{}, false
+		}
+	case "math.Sqrt":
+		if b.GOARCH != "wasm" && b.GOARCH != "amd64" && b.GOARCH != "386" {
+			return llvm.Value{}, false
+		}
+	default:
+		return llvm.Value{}, false // only the above functions are supported.
+	}
+
+	llvmFn := b.mod.NamedFunction(mathToLLVMMapping[name])
+	if llvmFn.IsNil() {
+		// The intrinsic doesn't exist yet, so declare it.
+		// At the moment, all supported intrinsics have the form "double
+		// foo(double %x)" so we can hardcode the signature here.
+		llvmType := llvm.FunctionType(b.ctx.DoubleType(), []llvm.Type{b.ctx.DoubleType()}, false)
+		llvmFn = llvm.AddFunction(b.mod, mathToLLVMMapping[name], llvmType)
+	}
+	// Create a call to the intrinsic.
+	args := make([]llvm.Value, len(call.Args))
+	for i, arg := range call.Args {
+		args[i] = b.getValue(arg)
+	}
+	return b.CreateCall(llvmFn, args, ""), true
+}

compiler/llvm.go

@@ -1,6 +1,11 @@
 package compiler
 
 import (
+	"fmt"
+	"go/token"
+	"go/types"
+	"math/big"
+
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"tinygo.org/x/go-llvm"
 )
@@ -8,21 +13,6 @@ import (
 // This file contains helper functions for LLVM that are not exposed in the Go
 // bindings.
 
-// Return a list of values (actually, instructions) where this value is used as
-// an operand.
-func getUses(value llvm.Value) []llvm.Value {
-	if value.IsNil() {
-		return nil
-	}
-	var uses []llvm.Value
-	use := value.FirstUse()
-	for !use.IsNil() {
-		uses = append(uses, use.User())
-		use = use.NextUse()
-	}
-	return uses
-}
-
 // createTemporaryAlloca creates a new alloca in the entry block and adds
 // lifetime start information in the IR signalling that the alloca won't be used
 // before this point.
@@ -44,7 +34,7 @@ func (b *builder) emitLifetimeEnd(ptr, size llvm.Value) {
 // 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 (b *builder) emitPointerPack(values []llvm.Value) llvm.Value {
-	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.Config, values)
+	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.pkg.Path(), b.NeedsStackObjects, values)
 }
 
 // emitPointerUnpack extracts a list of values packed using emitPointerPack.
@@ -67,3 +57,199 @@ func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType l
 	global.SetInitializer(value)
 	return global
 }
+
+// createObjectLayout returns a LLVM value (of type i8*) that describes where
+// there are pointers in the type t. If all the data fits in a word, it is
+// returned as a word. Otherwise it will store the data in a global.
+//
+// The value contains two pieces of information: the length of the object and
+// which words contain a pointer (indicated by setting the given bit to 1). For
+// arrays, only the element is stored. This works because the GC knows the
+// object size and can therefore know how this value is repeated in the object.
+func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Value {
+	// Use the element type for arrays. This works even for nested arrays.
+	for {
+		kind := t.TypeKind()
+		if kind == llvm.ArrayTypeKind {
+			t = t.ElementType()
+			continue
+		}
+		if kind == llvm.StructTypeKind {
+			fields := t.StructElementTypes()
+			if len(fields) == 1 {
+				t = fields[0]
+				continue
+			}
+		}
+		break
+	}
+
+	// Do a few checks to see whether we need to generate any object layout
+	// information at all.
+	objectSizeBytes := c.targetData.TypeAllocSize(t)
+	pointerSize := c.targetData.TypeAllocSize(c.i8ptrType)
+	pointerAlignment := c.targetData.PrefTypeAlignment(c.i8ptrType)
+	if objectSizeBytes < pointerSize {
+		// Too small to contain a pointer.
+		layout := (uint64(1) << 1) | 1
+		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.i8ptrType)
+	}
+	bitmap := c.getPointerBitmap(t, pos)
+	if bitmap.BitLen() == 0 {
+		// There are no pointers in this type, so we can simplify the layout.
+		// TODO: this can be done in many other cases, e.g. when allocating an
+		// array (like [4][]byte, which repeats a slice 4 times).
+		layout := (uint64(1) << 1) | 1
+		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.i8ptrType)
+	}
+	if objectSizeBytes%uint64(pointerAlignment) != 0 {
+		// This shouldn't happen except for packed structs, which aren't
+		// currently used.
+		c.addError(pos, "internal error: unexpected object size for object with pointer field")
+		return llvm.ConstNull(c.i8ptrType)
+	}
+	objectSizeWords := objectSizeBytes / uint64(pointerAlignment)
+
+	pointerBits := pointerSize * 8
+	var sizeFieldBits uint64
+	switch pointerBits {
+	case 16:
+		sizeFieldBits = 4
+	case 32:
+		sizeFieldBits = 5
+	case 64:
+		sizeFieldBits = 6
+	default:
+		panic("unknown pointer size")
+	}
+	layoutFieldBits := pointerBits - 1 - sizeFieldBits
+
+	// Try to emit the value as an inline integer. This is possible in most
+	// cases.
+	if objectSizeWords < layoutFieldBits {
+		// If it can be stored directly in the pointer value, do so.
+		// The runtime knows that if the least significant bit of the pointer is
+		// set, the pointer contains the value itself.
+		layout := bitmap.Uint64()<<(sizeFieldBits+1) | (objectSizeWords << 1) | 1
+		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.i8ptrType)
+	}
+
+	// Unfortunately, the object layout is too big to fit in a pointer-sized
+	// integer. Store it in a global instead.
+
+	// Try first whether the global already exists. All objects with a
+	// particular name have the same type, so this is possible.
+	globalName := "runtime/gc.layout:" + fmt.Sprintf("%d-%0*x", objectSizeWords, (objectSizeWords+15)/16, bitmap)
+	global := c.mod.NamedGlobal(globalName)
+	if !global.IsNil() {
+		return llvm.ConstBitCast(global, c.i8ptrType)
+	}
+
+	// Create the global initializer.
+	bitmapBytes := make([]byte, int(objectSizeWords+7)/8)
+	copy(bitmapBytes, bitmap.Bytes())
+	var bitmapByteValues []llvm.Value
+	for _, b := range bitmapBytes {
+		bitmapByteValues = append(bitmapByteValues, llvm.ConstInt(c.ctx.Int8Type(), uint64(b), false))
+	}
+	initializer := c.ctx.ConstStruct([]llvm.Value{
+		llvm.ConstInt(c.uintptrType, objectSizeWords, false),
+		llvm.ConstArray(c.ctx.Int8Type(), bitmapByteValues),
+	}, false)
+
+	global = llvm.AddGlobal(c.mod, initializer.Type(), globalName)
+	global.SetInitializer(initializer)
+	global.SetUnnamedAddr(true)
+	global.SetGlobalConstant(true)
+	global.SetLinkage(llvm.LinkOnceODRLinkage)
+	if c.targetData.PrefTypeAlignment(c.uintptrType) < 2 {
+		// AVR doesn't have alignment by default.
+		global.SetAlignment(2)
+	}
+	if c.Debug && pos != token.NoPos {
+		// Creating a fake global so that the value can be inspected in GDB.
+		// For example, the layout for strings.stringFinder (as of Go version
+		// 1.15) has the following type according to GDB:
+		//   type = struct {
+		//       uintptr numBits;
+		//       uint8 data[33];
+		//   }
+		// ...that's sort of a mixed C/Go type, but it is readable. More
+		// importantly, these object layout globals can be read and printed by
+		// GDB which may be useful for debugging.
+		position := c.program.Fset.Position(pos)
+		diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[position.Filename], llvm.DIGlobalVariableExpression{
+			Name: globalName,
+			File: c.getDIFile(position.Filename),
+			Line: position.Line,
+			Type: c.getDIType(types.NewStruct([]*types.Var{
+				types.NewVar(pos, nil, "numBits", types.Typ[types.Uintptr]),
+				types.NewVar(pos, nil, "data", types.NewArray(types.Typ[types.Byte], int64(len(bitmapByteValues)))),
+			}, nil)),
+			LocalToUnit: false,
+			Expr:        c.dibuilder.CreateExpression(nil),
+		})
+		global.AddMetadata(0, diglobal)
+	}
+
+	return llvm.ConstBitCast(global, c.i8ptrType)
+}
+
+// getPointerBitmap scans the given LLVM type for pointers and sets bits in a
+// bigint at the word offset that contains a pointer. This scan is recursive.
+func (c *compilerContext) getPointerBitmap(typ llvm.Type, pos token.Pos) *big.Int {
+	alignment := c.targetData.PrefTypeAlignment(c.i8ptrType)
+	switch typ.TypeKind() {
+	case llvm.IntegerTypeKind, llvm.FloatTypeKind, llvm.DoubleTypeKind:
+		return big.NewInt(0)
+	case llvm.PointerTypeKind:
+		return big.NewInt(1)
+	case llvm.StructTypeKind:
+		ptrs := big.NewInt(0)
+		if typ.StructName() == "runtime.funcValue" {
+			// Hack: the type runtime.funcValue contains an 'id' field which is
+			// of type uintptr, but before the LowerFuncValues pass it actually
+			// contains a pointer (ptrtoint) to a global. This trips up the
+			// interp package. Therefore, make the id field a pointer for now.
+			typ = c.ctx.StructType([]llvm.Type{c.i8ptrType, c.i8ptrType}, false)
+		}
+		for i, subtyp := range typ.StructElementTypes() {
+			subptrs := c.getPointerBitmap(subtyp, pos)
+			if subptrs.BitLen() == 0 {
+				continue
+			}
+			offset := c.targetData.ElementOffset(typ, i)
+			if offset%uint64(alignment) != 0 {
+				// This error will let the compilation fail, but by continuing
+				// the error can still easily be shown.
+				c.addError(pos, "internal error: allocated struct contains unaligned pointer")
+				continue
+			}
+			subptrs.Lsh(subptrs, uint(offset)/uint(alignment))
+			ptrs.Or(ptrs, subptrs)
+		}
+		return ptrs
+	case llvm.ArrayTypeKind:
+		subtyp := typ.ElementType()
+		subptrs := c.getPointerBitmap(subtyp, pos)
+		ptrs := big.NewInt(0)
+		if subptrs.BitLen() == 0 {
+			return ptrs
+		}
+		elementSize := c.targetData.TypeAllocSize(subtyp)
+		if elementSize%uint64(alignment) != 0 {
+			// This error will let the compilation fail (but continues so that
+			// other errors can be shown).
+			c.addError(pos, "internal error: allocated array contains unaligned pointer")
+			return ptrs
+		}
+		for i := 0; i < typ.ArrayLength(); i++ {
+			ptrs.Lsh(ptrs, uint(elementSize)/uint(alignment))
+			ptrs.Or(ptrs, subptrs)
+		}
+		return ptrs
+	default:
+		// Should not happen.
+		panic("unknown LLVM type")
+	}
+}

compiler/llvmutil/wordpack.go

@@ -5,7 +5,6 @@ package llvmutil
 // itself if possible and legal.
 
 import (
-	"github.com/tinygo-org/tinygo/compileopts"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -13,7 +12,7 @@ import (
 // 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.
 // If the values are all constants, they are be stored in a constant global and deduplicated.
-func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.Config, values []llvm.Value) llvm.Value {
+func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needsStackObjects bool, values []llvm.Value) llvm.Value {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
 	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
@@ -84,12 +83,11 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.
 		if constant {
 			// The data is known at compile time, so store it in a constant global.
 			// The global address is marked as unnamed, which allows LLVM to merge duplicates.
-			funcName := builder.GetInsertBlock().Parent().Name()
-			global := llvm.AddGlobal(mod, packedType, funcName+"$pack")
+			global := llvm.AddGlobal(mod, packedType, prefix+"$pack")
 			global.SetInitializer(ctx.ConstStruct(values, false))
 			global.SetGlobalConstant(true)
 			global.SetUnnamedAddr(true)
-			global.SetLinkage(llvm.PrivateLinkage)
+			global.SetLinkage(llvm.InternalLinkage)
 			return llvm.ConstBitCast(global, i8ptrType)
 		}
 
@@ -98,10 +96,11 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.
 		alloc := mod.NamedFunction("runtime.alloc")
 		packedHeapAlloc := builder.CreateCall(alloc, []llvm.Value{
 			sizeValue,
+			llvm.ConstNull(i8ptrType),
 			llvm.Undef(i8ptrType),            // unused context parameter
 			llvm.ConstPointerNull(i8ptrType), // coroutine handle
 		}, "")
-		if config.NeedsStackObjects() {
+		if needsStackObjects {
 			trackPointer := mod.NamedFunction("runtime.trackPointer")
 			builder.CreateCall(trackPointer, []llvm.Value{
 				packedHeapAlloc,

compiler/sizes.go

@@ -150,6 +150,9 @@ func (s *stdSizes) Sizeof(T types.Type) int64 {
 		return s.PtrSize * 2
 	case *types.Pointer:
 		return s.PtrSize
+	case *types.Signature:
+		// Func values in TinyGo are two words in size.
+		return s.PtrSize * 2
 	default:
 		panic("unknown type: " + t.String())
 	}

compiler/symbol.go

@@ -15,6 +15,361 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
+// functionInfo contains some information about a function or method. In
+// particular, it contains information obtained from pragmas.
+//
+// The linkName value contains a valid link name, even if //go:linkname is not
+// present.
+type functionInfo struct {
+	module     string     // go:wasm-module
+	importName string     // go:linkname, go:export - The name the developer assigns
+	linkName   string     // go:linkname, go:export - The name that we map for the particular module -> importName
+	section    string     // go:section - object file section name
+	exported   bool       // go:export, CGo
+	interrupt  bool       // go:interrupt
+	nobounds   bool       // go:nobounds
+	variadic   bool       // go:variadic (CGo only)
+	inline     inlineType // go:inline
+}
+
+type inlineType int
+
+// How much to inline.
+const (
+	// Default behavior. The compiler decides for itself whether any given
+	// function will be inlined. Whether any function is inlined depends on the
+	// optimization level.
+	inlineDefault inlineType = iota
+
+	// Inline hint, just like the C inline keyword (signalled using
+	// //go:inline). The compiler will be more likely to inline this function,
+	// but it is not a guarantee.
+	inlineHint
+
+	// Don't inline, just like the GCC noinline attribute. Signalled using
+	// //go:noinline.
+	inlineNone
+)
+
+// getFunction returns the LLVM function for the given *ssa.Function, creating
+// it if needed. It can later be filled with compilerContext.createFunction().
+func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
+	info := c.getFunctionInfo(fn)
+	llvmFn := c.mod.NamedFunction(info.linkName)
+	if !llvmFn.IsNil() {
+		return llvmFn
+	}
+
+	var retType llvm.Type
+	if fn.Signature.Results() == nil {
+		retType = c.ctx.VoidType()
+	} else if fn.Signature.Results().Len() == 1 {
+		retType = c.getLLVMType(fn.Signature.Results().At(0).Type())
+	} else {
+		results := make([]llvm.Type, 0, fn.Signature.Results().Len())
+		for i := 0; i < fn.Signature.Results().Len(); i++ {
+			results = append(results, c.getLLVMType(fn.Signature.Results().At(i).Type()))
+		}
+		retType = c.ctx.StructType(results, false)
+	}
+
+	var paramInfos []paramInfo
+	for _, param := range getParams(fn.Signature) {
+		paramType := c.getLLVMType(param.Type())
+		paramFragmentInfos := c.expandFormalParamType(paramType, param.Name(), param.Type())
+		paramInfos = append(paramInfos, paramFragmentInfos...)
+	}
+
+	// Add an extra parameter as the function context. This context is used in
+	// closures and bound methods, but should be optimized away when not used.
+	if !info.exported {
+		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "context", flags: 0})
+		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "parentHandle", flags: 0})
+	}
+
+	var paramTypes []llvm.Type
+	for _, info := range paramInfos {
+		paramTypes = append(paramTypes, info.llvmType)
+	}
+
+	fnType := llvm.FunctionType(retType, paramTypes, info.variadic)
+	llvmFn = llvm.AddFunction(c.mod, info.linkName, fnType)
+	if strings.HasPrefix(c.Triple, "wasm") {
+		// C functions without prototypes like this:
+		//   void foo();
+		// are actually variadic functions. However, it appears that it has been
+		// decided in WebAssembly that such prototype-less functions are not
+		// allowed in WebAssembly.
+		// In C, this can only happen when there are zero parameters, hence this
+		// check here. For more information:
+		// https://reviews.llvm.org/D48443
+		// https://github.com/WebAssembly/tool-conventions/issues/16
+		if info.variadic && len(fn.Params) == 0 {
+			attr := c.ctx.CreateStringAttribute("no-prototype", "")
+			llvmFn.AddFunctionAttr(attr)
+		}
+	}
+	c.addStandardDeclaredAttributes(llvmFn)
+
+	dereferenceableOrNullKind := llvm.AttributeKindID("dereferenceable_or_null")
+	for i, info := range paramInfos {
+		if info.flags&paramIsDeferenceableOrNull == 0 {
+			continue
+		}
+		if info.llvmType.TypeKind() == llvm.PointerTypeKind {
+			el := info.llvmType.ElementType()
+			size := c.targetData.TypeAllocSize(el)
+			if size == 0 {
+				// dereferenceable_or_null(0) appears to be illegal in LLVM.
+				continue
+			}
+			dereferenceableOrNull := c.ctx.CreateEnumAttribute(dereferenceableOrNullKind, size)
+			llvmFn.AddAttributeAtIndex(i+1, dereferenceableOrNull)
+		}
+	}
+
+	// Set a number of function or parameter attributes, depending on the
+	// function. These functions are runtime functions that are known to have
+	// certain attributes that might not be inferred by the compiler.
+	switch info.linkName {
+	case "abort":
+		// On *nix systems, the "abort" functuion in libc is used to handle fatal panics.
+		// Mark it as noreturn so LLVM can optimize away code.
+		llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("noreturn"), 0))
+	case "runtime.alloc":
+		// Tell the optimizer that runtime.alloc is an allocator, meaning that it
+		// returns values that are never null and never alias to an existing value.
+		for _, attrName := range []string{"noalias", "nonnull"} {
+			llvmFn.AddAttributeAtIndex(0, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(attrName), 0))
+		}
+	case "runtime.sliceAppend":
+		// Appending a slice will only read the to-be-appended slice, it won't
+		// be modified.
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
+	case "runtime.sliceCopy":
+		// Copying a slice won't capture any of the parameters.
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("writeonly"), 0))
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+	case "runtime.trackPointer":
+		// This function is necessary for tracking pointers on the stack in a
+		// portable way (see gc_stack_portable.go). Indicate to the optimizer
+		// that the only thing we'll do is read the pointer.
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
+	}
+
+	// External/exported functions may not retain pointer values.
+	// https://golang.org/cmd/cgo/#hdr-Passing_pointers
+	if info.exported {
+		// Set the wasm-import-module attribute if the function's module is set.
+		if info.module != "" {
+
+			// We need to add the wasm-import-module and the wasm-import-name
+			wasmImportModuleAttr := c.ctx.CreateStringAttribute("wasm-import-module", info.module)
+			llvmFn.AddFunctionAttr(wasmImportModuleAttr)
+
+			// Add the Wasm Import Name, if we are a named wasm import
+			if info.importName != "" {
+				wasmImportNameAttr := c.ctx.CreateStringAttribute("wasm-import-name", info.importName)
+				llvmFn.AddFunctionAttr(wasmImportNameAttr)
+			}
+		}
+		nocaptureKind := llvm.AttributeKindID("nocapture")
+		nocapture := c.ctx.CreateEnumAttribute(nocaptureKind, 0)
+		for i, typ := range paramTypes {
+			if typ.TypeKind() == llvm.PointerTypeKind {
+				llvmFn.AddAttributeAtIndex(i+1, nocapture)
+			}
+		}
+	}
+
+	// Synthetic functions are functions that do not appear in the source code,
+	// they are artificially constructed. Usually they are wrapper functions
+	// that are not referenced anywhere except in a SSA call instruction so
+	// should be created right away.
+	// The exception is the package initializer, which does appear in the
+	// *ssa.Package members and so shouldn't be created here.
+	if fn.Synthetic != "" && fn.Synthetic != "package initializer" {
+		irbuilder := c.ctx.NewBuilder()
+		b := newBuilder(c, irbuilder, fn)
+		b.createFunction()
+		irbuilder.Dispose()
+		llvmFn.SetLinkage(llvm.LinkOnceODRLinkage)
+		llvmFn.SetUnnamedAddr(true)
+	}
+
+	return llvmFn
+}
+
+// getFunctionInfo returns information about a function that is not directly
+// present in *ssa.Function, such as the link name and whether it should be
+// exported.
+func (c *compilerContext) getFunctionInfo(f *ssa.Function) functionInfo {
+	info := functionInfo{}
+	if strings.HasPrefix(f.Name(), "C.") {
+		// Created by CGo: such a name cannot be created by regular C code.
+		info.linkName = f.Name()[2:]
+		info.exported = true
+	} else {
+		// Pick the default linkName.
+		info.linkName = f.RelString(nil)
+	}
+	// Check for //go: pragmas, which may change the link name (among others).
+	info.parsePragmas(f)
+	return info
+}
+
+// parsePragmas is used by getFunctionInfo to parse function pragmas such as
+// //export or //go:noinline.
+func (info *functionInfo) parsePragmas(f *ssa.Function) {
+	if f.Syntax() == nil {
+		return
+	}
+	if decl, ok := f.Syntax().(*ast.FuncDecl); ok && decl.Doc != nil {
+
+		// Our importName for a wasm module (if we are compiling to wasm), or llvm link name
+		var importName string
+
+		for _, comment := range decl.Doc.List {
+			text := comment.Text
+			if strings.HasPrefix(text, "//export ") {
+				// Rewrite '//export' to '//go:export' for compatibility with
+				// gc.
+				text = "//go:" + text[2:]
+			}
+			if !strings.HasPrefix(text, "//go:") {
+				continue
+			}
+			parts := strings.Fields(text)
+			switch parts[0] {
+			case "//go:export":
+				if len(parts) != 2 {
+					continue
+				}
+
+				importName = parts[1]
+				info.exported = true
+			case "//go:interrupt":
+				if hasUnsafeImport(f.Pkg.Pkg) {
+					info.interrupt = true
+				}
+			case "//go:wasm-module":
+				// Alternative comment for setting the import module.
+				if len(parts) != 2 {
+					continue
+				}
+				info.module = parts[1]
+			case "//go:inline":
+				info.inline = inlineHint
+			case "//go:noinline":
+				info.inline = inlineNone
+			case "//go:linkname":
+				if len(parts) != 3 || parts[1] != f.Name() {
+					continue
+				}
+				// Only enable go:linkname when the package imports "unsafe".
+				// This is a slightly looser requirement than what gc uses: gc
+				// requires the file to import "unsafe", not the package as a
+				// whole.
+				if hasUnsafeImport(f.Pkg.Pkg) {
+					info.linkName = parts[2]
+				}
+			case "//go:section":
+				if len(parts) == 2 && hasUnsafeImport(f.Pkg.Pkg) {
+					info.section = parts[1]
+				}
+			case "//go:nobounds":
+				// Skip bounds checking in this function. Useful for some
+				// runtime functions.
+				// This is somewhat dangerous and thus only imported in packages
+				// that import unsafe.
+				if hasUnsafeImport(f.Pkg.Pkg) {
+					info.nobounds = true
+				}
+			case "//go:variadic":
+				// The //go:variadic pragma is emitted by the CGo preprocessing
+				// pass for C variadic functions. This includes both explicit
+				// (with ...) and implicit (no parameters in signature)
+				// functions.
+				if strings.HasPrefix(f.Name(), "C.") {
+					// This prefix cannot naturally be created, it must have
+					// been created as a result of CGo preprocessing.
+					info.variadic = true
+				}
+			}
+		}
+
+		// Set the importName for our exported function if we have one
+		if importName != "" {
+			if info.module == "" {
+				info.linkName = importName
+			} else {
+				// WebAssembly import
+				info.importName = importName
+			}
+		}
+
+	}
+}
+
+// getParams returns the function parameters, including the receiver at the
+// start. This is an alternative to the Params member of *ssa.Function, which is
+// not yet populated when the package has not yet been built.
+func getParams(sig *types.Signature) []*types.Var {
+	params := []*types.Var{}
+	if sig.Recv() != nil {
+		params = append(params, sig.Recv())
+	}
+	for i := 0; i < sig.Params().Len(); i++ {
+		params = append(params, sig.Params().At(i))
+	}
+	return params
+}
+
+// addStandardDeclaredAttributes adds attributes that are set for any function,
+// whether declared or defined.
+func (c *compilerContext) addStandardDeclaredAttributes(llvmFn llvm.Value) {
+	if c.SizeLevel >= 1 {
+		// Set the "optsize" attribute to make slightly smaller binaries at the
+		// cost of minimal performance loss (-Os in Clang).
+		kind := llvm.AttributeKindID("optsize")
+		attr := c.ctx.CreateEnumAttribute(kind, 0)
+		llvmFn.AddFunctionAttr(attr)
+	}
+	if c.SizeLevel >= 2 {
+		// Set the "minsize" attribute to reduce code size even further,
+		// regardless of performance loss (-Oz in Clang).
+		kind := llvm.AttributeKindID("minsize")
+		attr := c.ctx.CreateEnumAttribute(kind, 0)
+		llvmFn.AddFunctionAttr(attr)
+	}
+}
+
+// addStandardDefinedAttributes adds the set of attributes that are added to
+// every function defined by TinyGo (even thunks/wrappers), possibly depending
+// on the architecture. It does not set attributes only set for declared
+// functions, use addStandardDeclaredAttributes for this.
+func (c *compilerContext) addStandardDefinedAttributes(llvmFn llvm.Value) {
+	// TinyGo does not currently raise exceptions, so set the 'nounwind' flag.
+	// This behavior matches Clang when compiling C source files.
+	// It reduces binary size on Linux a little bit on non-x86_64 targets by
+	// eliminating exception tables for these functions.
+	llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nounwind"), 0))
+	if strings.Split(c.Triple, "-")[0] == "x86_64" {
+		// Required by the ABI.
+		llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("uwtable"), 0))
+	}
+}
+
+// addStandardAttribute adds all attributes added to defined functions.
+func (c *compilerContext) addStandardAttributes(llvmFn llvm.Value) {
+	c.addStandardDeclaredAttributes(llvmFn)
+	c.addStandardDefinedAttributes(llvmFn)
+}
+
 // globalInfo contains some information about a specific global. By default,
 // linkName is equal to .RelString(nil) on a global and extern is false, but for
 // some symbols this is different (due to //go:extern for example).
@@ -22,29 +377,27 @@ type globalInfo struct {
 	linkName string // go:extern
 	extern   bool   // go:extern
 	align    int    // go:align
+	section  string // go:section
 }
 
 // loadASTComments loads comments on globals from the AST, for use later in the
 // program. In particular, they are required for //go:extern pragmas on globals.
-func (c *compilerContext) loadASTComments(lprogram *loader.Program) {
-	c.astComments = map[string]*ast.CommentGroup{}
-	for _, pkgInfo := range lprogram.Sorted() {
-		for _, file := range pkgInfo.Files {
-			for _, decl := range file.Decls {
-				switch decl := decl.(type) {
-				case *ast.GenDecl:
-					switch decl.Tok {
-					case token.VAR:
-						if len(decl.Specs) != 1 {
-							continue
-						}
-						for _, spec := range decl.Specs {
-							switch spec := spec.(type) {
-							case *ast.ValueSpec: // decl.Tok == token.VAR
-								for _, name := range spec.Names {
-									id := pkgInfo.Pkg.Path() + "." + name.Name
-									c.astComments[id] = decl.Doc
-								}
+func (c *compilerContext) loadASTComments(pkg *loader.Package) {
+	for _, file := range pkg.Files {
+		for _, decl := range file.Decls {
+			switch decl := decl.(type) {
+			case *ast.GenDecl:
+				switch decl.Tok {
+				case token.VAR:
+					if len(decl.Specs) != 1 {
+						continue
+					}
+					for _, spec := range decl.Specs {
+						switch spec := spec.(type) {
+						case *ast.ValueSpec: // decl.Tok == token.VAR
+							for _, name := range spec.Names {
+								id := pkg.Pkg.Path() + "." + name.Name
+								c.astComments[id] = decl.Doc
 							}
 						}
 					}
@@ -63,30 +416,26 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 		typ := g.Type().(*types.Pointer).Elem()
 		llvmType := c.getLLVMType(typ)
 		llvmGlobal = llvm.AddGlobal(c.mod, llvmType, info.linkName)
-		if !info.extern {
-			llvmGlobal.SetInitializer(llvm.ConstNull(llvmType))
-			llvmGlobal.SetLinkage(llvm.InternalLinkage)
-		}
 
 		// Set alignment from the //go:align comment.
 		var alignInBits uint32
-		if info.align < 0 || info.align&(info.align-1) != 0 {
+		alignment := c.targetData.ABITypeAlignment(llvmType)
+		if info.align > alignment {
+			alignment = info.align
+		}
+		if alignment <= 0 || alignment&(alignment-1) != 0 {
 			// Check for power-of-two (or 0).
 			// See: https://stackoverflow.com/a/108360
 			c.addError(g.Pos(), "global variable alignment must be a positive power of two")
 		} else {
 			// Set the alignment only when it is a power of two.
-			alignInBits = uint32(info.align) ^ uint32(info.align-1)
-			if info.align > c.targetData.ABITypeAlignment(llvmType) {
-				llvmGlobal.SetAlignment(info.align)
-			}
+			alignInBits = uint32(alignment) ^ uint32(alignment-1)
+			llvmGlobal.SetAlignment(alignment)
 		}
 
-		if c.Debug() && !info.extern {
+		if c.Debug && !info.extern {
 			// Add debug info.
-			// TODO: this should be done for every global in the program, not just
-			// the ones that are referenced from some code.
-			pos := c.ir.Program.Fset.Position(g.Pos())
+			pos := c.program.Fset.Position(g.Pos())
 			diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[pos.Filename], llvm.DIGlobalVariableExpression{
 				Name:        g.RelString(nil),
 				LinkageName: info.linkName,
@@ -142,6 +491,30 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 			if err == nil {
 				info.align = align
 			}
+		case "//go:section":
+			if len(parts) == 2 {
+				info.section = parts[1]
+			}
 		}
 	}
 }
+
+// Get all methods of a type.
+func getAllMethods(prog *ssa.Program, typ types.Type) []*types.Selection {
+	ms := prog.MethodSets.MethodSet(typ)
+	methods := make([]*types.Selection, ms.Len())
+	for i := 0; i < ms.Len(); i++ {
+		methods[i] = ms.At(i)
+	}
+	return methods
+}
+
+// Return true if this package imports "unsafe", false otherwise.
+func hasUnsafeImport(pkg *types.Package) bool {
+	for _, imp := range pkg.Imports() {
+		if imp == types.Unsafe {
+			return true
+		}
+	}
+	return false
+}

compiler/syscall.go

@@ -10,14 +10,14 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
-// createSyscall emits an inline system call instruction, depending on the
-// target OS/arch.
-func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
+// createRawSyscall creates a system call with the provided system call number
+// and returns the result as a single integer (the system call result). The
+// result is not further interpreted.
+func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 	num := b.getValue(call.Args[0])
-	var syscallResult llvm.Value
 	switch {
-	case b.GOARCH() == "amd64":
-		if b.GOOS() == "darwin" {
+	case b.GOARCH == "amd64":
+		if b.GOOS == "darwin" {
 			// Darwin adds this magic number to system call numbers:
 			//
 			// > Syscall classes for 64-bit system call entry.
@@ -57,8 +57,8 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		constraints += ",~{rcx},~{r11}"
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel)
-		syscallResult = b.CreateCall(target, args, "")
-	case b.GOARCH() == "386" && b.GOOS() == "linux":
+		return b.CreateCall(target, args, ""), nil
+	case b.GOARCH == "386" && b.GOOS == "linux":
 		// Sources:
 		//   syscall(2) man page
 		//   https://stackoverflow.com/a/2538212
@@ -83,8 +83,8 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel)
-		syscallResult = b.CreateCall(target, args, "")
-	case b.GOARCH() == "arm" && b.GOOS() == "linux":
+		return b.CreateCall(target, args, ""), nil
+	case b.GOARCH == "arm" && b.GOOS == "linux":
 		// Implement the EABI system call convention for Linux.
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
@@ -115,8 +115,8 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
-		syscallResult = b.CreateCall(target, args, "")
-	case b.GOARCH() == "arm64" && b.GOOS() == "linux":
+		return b.CreateCall(target, args, ""), nil
+	case b.GOARCH == "arm64" && b.GOOS == "linux":
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
 		argTypes := []llvm.Type{}
@@ -147,11 +147,20 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		constraints += ",~{x16},~{x17}" // scratch registers
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
-		syscallResult = b.CreateCall(target, args, "")
+		return b.CreateCall(target, args, ""), nil
 	default:
-		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS()+"/"+b.GOARCH())
+		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS+"/"+b.GOARCH)
 	}
-	switch b.GOOS() {
+}
+
+// createSyscall emits instructions for the syscall.Syscall* family of
+// functions, depending on the target OS/arch.
+func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
+	syscallResult, err := b.createRawSyscall(call)
+	if err != nil {
+		return syscallResult, err
+	}
+	switch b.GOOS {
 	case "linux", "freebsd":
 		// Return values: r0, r1 uintptr, err Errno
 		// Pseudocode:
@@ -187,6 +196,19 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		retval = b.CreateInsertValue(retval, errResult, 2, "")
 		return retval, nil
 	default:
-		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS()+"/"+b.GOARCH())
+		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS+"/"+b.GOARCH)
 	}
 }
+
+// createRawSyscallNoError emits instructions for the Linux-specific
+// syscall.rawSyscallNoError function.
+func (b *builder) createRawSyscallNoError(call *ssa.CallCommon) (llvm.Value, error) {
+	syscallResult, err := b.createRawSyscall(call)
+	if err != nil {
+		return syscallResult, err
+	}
+	retval := llvm.ConstNull(b.ctx.StructType([]llvm.Type{b.uintptrType, b.uintptrType}, false))
+	retval = b.CreateInsertValue(retval, syscallResult, 0, "")
+	retval = b.CreateInsertValue(retval, llvm.ConstInt(b.uintptrType, 0, false), 1, "")
+	return retval, nil
+}

compiler/testdata/basic.go

@@ -0,0 +1,88 @@
+package main
+
+// Basic tests that don't need to be split into a separate file.
+
+func addInt(x, y int) int {
+	return x + y
+}
+
+func equalInt(x, y int) bool {
+	return x == y
+}
+
+func divInt(x, y int) int {
+	return x / y
+}
+
+func divUint(x, y uint) uint {
+	return x / y
+}
+
+func remInt(x, y int) int {
+	return x % y
+}
+
+func remUint(x, y uint) uint {
+	return x % y
+}
+
+func floatEQ(x, y float32) bool {
+	return x == y
+}
+
+func floatNE(x, y float32) bool {
+	return x != y
+}
+
+func floatLower(x, y float32) bool {
+	return x < y
+}
+
+func floatLowerEqual(x, y float32) bool {
+	return x <= y
+}
+
+func floatGreater(x, y float32) bool {
+	return x > y
+}
+
+func floatGreaterEqual(x, y float32) bool {
+	return x >= y
+}
+
+func complexReal(x complex64) float32 {
+	return real(x)
+}
+
+func complexImag(x complex64) float32 {
+	return imag(x)
+}
+
+func complexAdd(x, y complex64) complex64 {
+	return x + y
+}
+
+func complexSub(x, y complex64) complex64 {
+	return x - y
+}
+
+func complexMul(x, y complex64) complex64 {
+	return x * y
+}
+
+// TODO: complexDiv (requires runtime call)
+
+// A type 'kv' also exists in function foo. Test that these two types don't
+// conflict with each other.
+type kv struct {
+	v float32
+}
+
+func foo(a *kv) {
+	// Define a new 'kv' type.
+	type kv struct {
+		v byte
+	}
+	// Use this type.
+	func(b *kv) {}(nil)
+}

compiler/testdata/basic.ll

@@ -0,0 +1,202 @@
+; ModuleID = 'basic.go'
+source_filename = "basic.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+%main.kv = type { float }
+%main.kv.0 = type { i8 }
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.addInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = add i32 %x, %y
+  ret i32 %0
+}
+
+; Function Attrs: nounwind
+define hidden i1 @main.equalInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp eq i32 %x, %y
+  ret i1 %0
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.divInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp eq i32 %y, 0
+  br i1 %0, label %divbyzero.throw, label %divbyzero.next
+
+divbyzero.throw:                                  ; preds = %entry
+  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
+  unreachable
+
+divbyzero.next:                                   ; preds = %entry
+  %1 = icmp eq i32 %y, -1
+  %2 = icmp eq i32 %x, -2147483648
+  %3 = and i1 %1, %2
+  %4 = select i1 %3, i32 1, i32 %y
+  %5 = sdiv i32 %x, %4
+  ret i32 %5
+}
+
+declare void @runtime.divideByZeroPanic(i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden i32 @main.divUint(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp eq i32 %y, 0
+  br i1 %0, label %divbyzero.throw, label %divbyzero.next
+
+divbyzero.throw:                                  ; preds = %entry
+  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
+  unreachable
+
+divbyzero.next:                                   ; preds = %entry
+  %1 = udiv i32 %x, %y
+  ret i32 %1
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.remInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp eq i32 %y, 0
+  br i1 %0, label %divbyzero.throw, label %divbyzero.next
+
+divbyzero.throw:                                  ; preds = %entry
+  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
+  unreachable
+
+divbyzero.next:                                   ; preds = %entry
+  %1 = icmp eq i32 %y, -1
+  %2 = icmp eq i32 %x, -2147483648
+  %3 = and i1 %1, %2
+  %4 = select i1 %3, i32 1, i32 %y
+  %5 = srem i32 %x, %4
+  ret i32 %5
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.remUint(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp eq i32 %y, 0
+  br i1 %0, label %divbyzero.throw, label %divbyzero.next
+
+divbyzero.throw:                                  ; preds = %entry
+  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
+  unreachable
+
+divbyzero.next:                                   ; preds = %entry
+  %1 = urem i32 %x, %y
+  ret i32 %1
+}
+
+; Function Attrs: nounwind
+define hidden i1 @main.floatEQ(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = fcmp oeq float %x, %y
+  ret i1 %0
+}
+
+; Function Attrs: nounwind
+define hidden i1 @main.floatNE(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = fcmp une float %x, %y
+  ret i1 %0
+}
+
+; Function Attrs: nounwind
+define hidden i1 @main.floatLower(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = fcmp olt float %x, %y
+  ret i1 %0
+}
+
+; Function Attrs: nounwind
+define hidden i1 @main.floatLowerEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = fcmp ole float %x, %y
+  ret i1 %0
+}
+
+; Function Attrs: nounwind
+define hidden i1 @main.floatGreater(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = fcmp ogt float %x, %y
+  ret i1 %0
+}
+
+; Function Attrs: nounwind
+define hidden i1 @main.floatGreaterEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = fcmp oge float %x, %y
+  ret i1 %0
+}
+
+; Function Attrs: nounwind
+define hidden float @main.complexReal(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret float %x.r
+}
+
+; Function Attrs: nounwind
+define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret float %x.i
+}
+
+; Function Attrs: nounwind
+define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = fadd float %x.r, %y.r
+  %1 = fadd float %x.i, %y.i
+  %2 = insertvalue { float, float } undef, float %0, 0
+  %3 = insertvalue { float, float } %2, float %1, 1
+  ret { float, float } %3
+}
+
+; Function Attrs: nounwind
+define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = fsub float %x.r, %y.r
+  %1 = fsub float %x.i, %y.i
+  %2 = insertvalue { float, float } undef, float %0, 0
+  %3 = insertvalue { float, float } %2, float %1, 1
+  ret { float, float } %3
+}
+
+; Function Attrs: nounwind
+define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = fmul float %x.r, %y.r
+  %1 = fmul float %x.i, %y.i
+  %2 = fsub float %0, %1
+  %3 = fmul float %x.r, %y.i
+  %4 = fmul float %x.i, %y.r
+  %5 = fadd float %3, %4
+  %6 = insertvalue { float, float } undef, float %2, 0
+  %7 = insertvalue { float, float } %6, float %5, 1
+  ret { float, float } %7
+}
+
+; Function Attrs: nounwind
+define hidden void @main.foo(%main.kv* dereferenceable_or_null(4) %a, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  call void @"main.foo$1"(%main.kv.0* null, i8* undef, i8* undef)
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @"main.foo$1"(%main.kv.0* dereferenceable_or_null(1) %b, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+attributes #0 = { nounwind }

compiler/testdata/channel.go

@@ -0,0 +1,25 @@
+package main
+
+func chanIntSend(ch chan int) {
+	ch <- 3
+}
+
+func chanIntRecv(ch chan int) {
+	<-ch
+}
+
+func chanZeroSend(ch chan struct{}) {
+	ch <- struct{}{}
+}
+
+func chanZeroRecv(ch chan struct{}) {
+	<-ch
+}
+
+func selectZeroRecv(ch1 chan int, ch2 chan struct{}) {
+	select {
+	case ch1 <- 1:
+	case <-ch2:
+	default:
+	}
+}

compiler/testdata/channel.ll

@@ -0,0 +1,121 @@
+; ModuleID = 'channel.go'
+source_filename = "channel.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
+%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
+%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
+%"internal/task.state" = type { i8* }
+%runtime.chanSelectState = type { %runtime.channel*, i8* }
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.chanIntSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
+  %chan.value = alloca i32, align 4
+  %chan.value.bitcast = bitcast i32* %chan.value to i8*
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
+  store i32 3, i32* %chan.value, align 4
+  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
+  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  call void @runtime.chanSend(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
+  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
+  ret void
+}
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
+
+declare void @runtime.chanSend(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*, i8*)
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1
+
+; Function Attrs: nounwind
+define hidden void @main.chanIntRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
+  %chan.value = alloca i32, align 4
+  %chan.value.bitcast = bitcast i32* %chan.value to i8*
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
+  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
+  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
+  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  ret void
+}
+
+declare i1 @runtime.chanRecv(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.chanZeroSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
+  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
+  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  call void @runtime.chanSend(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
+  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.chanZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
+  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
+  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
+  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.selectZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch1, %runtime.channel* dereferenceable_or_null(32) %ch2, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %select.states.alloca = alloca [2 x %runtime.chanSelectState], align 8
+  %select.send.value = alloca i32, align 4
+  store i32 1, i32* %select.send.value, align 4
+  %select.states.alloca.bitcast = bitcast [2 x %runtime.chanSelectState]* %select.states.alloca to i8*
+  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
+  %.repack = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 0
+  store %runtime.channel* %ch1, %runtime.channel** %.repack, align 8
+  %.repack1 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 1
+  %0 = bitcast i8** %.repack1 to i32**
+  store i32* %select.send.value, i32** %0, align 4
+  %.repack3 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 0
+  store %runtime.channel* %ch2, %runtime.channel** %.repack3, align 8
+  %.repack4 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 1
+  store i8* null, i8** %.repack4, align 4
+  %select.states = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0
+  %select.result = call { i32, i1 } @runtime.tryChanSelect(i8* undef, %runtime.chanSelectState* nonnull %select.states, i32 2, i32 2, i8* undef, i8* null) #0
+  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
+  %1 = extractvalue { i32, i1 } %select.result, 0
+  %2 = icmp eq i32 %1, 0
+  br i1 %2, label %select.done, label %select.next
+
+select.done:                                      ; preds = %select.body, %select.next, %entry
+  ret void
+
+select.next:                                      ; preds = %entry
+  %3 = icmp eq i32 %1, 1
+  br i1 %3, label %select.body, label %select.done
+
+select.body:                                      ; preds = %select.next
+  br label %select.done
+}
+
+declare { i32, i1 } @runtime.tryChanSelect(i8*, %runtime.chanSelectState*, i32, i32, i8*, i8*)
+
+attributes #0 = { nounwind }
+attributes #1 = { argmemonly nounwind willreturn }

compiler/testdata/float.go

@@ -0,0 +1,39 @@
+package main
+
+// Test converting floats to ints.
+
+func f32tou32(v float32) uint32 {
+	return uint32(v)
+}
+
+func maxu32f() float32 {
+	return float32(^uint32(0))
+}
+
+func maxu32tof32() uint32 {
+	f := float32(^uint32(0))
+	return uint32(f)
+}
+
+func inftoi32() (uint32, uint32, int32, int32) {
+	inf := 1.0
+	inf /= 0.0
+
+	return uint32(inf), uint32(-inf), int32(inf), int32(-inf)
+}
+
+func u32tof32tou32(v uint32) uint32 {
+	return uint32(float32(v))
+}
+
+func f32tou32tof32(v float32) float32 {
+	return float32(uint32(v))
+}
+
+func f32tou8(v float32) uint8 {
+	return uint8(v)
+}
+
+func f32toi8(v float32) int8 {
+	return int8(v)
+}

compiler/testdata/float.ll

@@ -0,0 +1,93 @@
+; ModuleID = 'float.go'
+source_filename = "float.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.f32tou32(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %positive = fcmp oge float %v, 0.000000e+00
+  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
+  %inbounds = and i1 %positive, %withinmax
+  %saturated = sext i1 %positive to i32
+  %normal = fptoui float %v to i32
+  %0 = select i1 %inbounds, i32 %normal, i32 %saturated
+  ret i32 %0
+}
+
+; Function Attrs: nounwind
+define hidden float @main.maxu32f(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret float 0x41F0000000000000
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.maxu32tof32(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret i32 -1
+}
+
+; Function Attrs: nounwind
+define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret { i32, i32, i32, i32 } { i32 -1, i32 0, i32 2147483647, i32 -2147483648 }
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.u32tof32tou32(i32 %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = uitofp i32 %v to float
+  %withinmax = fcmp ole float %0, 0x41EFFFFFC0000000
+  %normal = fptoui float %0 to i32
+  %1 = select i1 %withinmax, i32 %normal, i32 -1
+  ret i32 %1
+}
+
+; Function Attrs: nounwind
+define hidden float @main.f32tou32tof32(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %positive = fcmp oge float %v, 0.000000e+00
+  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
+  %inbounds = and i1 %positive, %withinmax
+  %saturated = sext i1 %positive to i32
+  %normal = fptoui float %v to i32
+  %0 = select i1 %inbounds, i32 %normal, i32 %saturated
+  %1 = uitofp i32 %0 to float
+  ret float %1
+}
+
+; Function Attrs: nounwind
+define hidden i8 @main.f32tou8(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %positive = fcmp oge float %v, 0.000000e+00
+  %withinmax = fcmp ole float %v, 2.550000e+02
+  %inbounds = and i1 %positive, %withinmax
+  %saturated = sext i1 %positive to i8
+  %normal = fptoui float %v to i8
+  %0 = select i1 %inbounds, i8 %normal, i8 %saturated
+  ret i8 %0
+}
+
+; Function Attrs: nounwind
+define hidden i8 @main.f32toi8(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %abovemin = fcmp oge float %v, -1.280000e+02
+  %belowmax = fcmp ole float %v, 1.270000e+02
+  %inbounds = and i1 %abovemin, %belowmax
+  %saturated = select i1 %abovemin, i8 127, i8 -128
+  %isnan = fcmp uno float %v, 0.000000e+00
+  %remapped = select i1 %isnan, i8 0, i8 %saturated
+  %normal = fptosi float %v to i8
+  %0 = select i1 %inbounds, i8 %normal, i8 %remapped
+  ret i8 %0
+}
+
+attributes #0 = { nounwind }

compiler/testdata/func.go

@@ -0,0 +1,12 @@
+package main
+
+func foo(callback func(int)) {
+	callback(3)
+}
+
+func bar() {
+	foo(someFunc)
+}
+
+func someFunc(int) {
+}

compiler/testdata/func.ll

@@ -0,0 +1,53 @@
+; ModuleID = 'func.go'
+source_filename = "func.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+%runtime.funcValueWithSignature = type { i32, i8* }
+
+@"reflect/types.funcid:func:{basic:int}{}" = external constant i8
+@"main.someFunc$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @main.someFunc to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.foo(i8* %callback.context, i32 %callback.funcptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i32 @runtime.getFuncPtr(i8* %callback.context, i32 %callback.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null) #0
+  %1 = icmp eq i32 %0, 0
+  br i1 %1, label %fpcall.throw, label %fpcall.next
+
+fpcall.throw:                                     ; preds = %entry
+  call void @runtime.nilPanic(i8* undef, i8* null) #0
+  unreachable
+
+fpcall.next:                                      ; preds = %entry
+  %2 = inttoptr i32 %0 to void (i32, i8*, i8*)*
+  call void %2(i32 3, i8* %callback.context, i8* undef) #0
+  ret void
+}
+
+declare i32 @runtime.getFuncPtr(i8*, i32, i8* dereferenceable_or_null(1), i8*, i8*)
+
+declare void @runtime.nilPanic(i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.bar(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  call void @main.foo(i8* undef, i32 ptrtoint (%runtime.funcValueWithSignature* @"main.someFunc$withSignature" to i32), i8* undef, i8* undef)
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.someFunc(i32 %arg0, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+attributes #0 = { nounwind }

compiler/testdata/gc.go

@@ -0,0 +1,72 @@
+package main
+
+var (
+	scalar1 *byte
+	scalar2 *int32
+	scalar3 *int64
+	scalar4 *float32
+
+	array1 *[3]byte
+	array2 *[71]byte
+	array3 *[3]*byte
+
+	struct1 *struct{}
+	struct2 *struct {
+		x int
+		y int
+	}
+	struct3 *struct {
+		x *byte
+		y [60]uintptr
+		z *byte
+	}
+
+	slice1 []byte
+	slice2 []*int
+	slice3 [][]byte
+)
+
+func newScalar() {
+	scalar1 = new(byte)
+	scalar2 = new(int32)
+	scalar3 = new(int64)
+	scalar4 = new(float32)
+}
+
+func newArray() {
+	array1 = new([3]byte)
+	array2 = new([71]byte)
+	array3 = new([3]*byte)
+}
+
+func newStruct() {
+	struct1 = new(struct{})
+	struct2 = new(struct {
+		x int
+		y int
+	})
+	struct3 = new(struct {
+		x *byte
+		y [60]uintptr
+		z *byte
+	})
+}
+
+func newFuncValue() *func() {
+	// On some platforms that use runtime.funcValue ("switch" style) function
+	// values, a func value is allocated as having two pointer words while the
+	// struct looks like {unsafe.Pointer; uintptr}. This is so that the interp
+	// package won't get confused, see getPointerBitmap in compiler/llvm.go for
+	// details.
+	return new(func())
+}
+
+func makeSlice() {
+	slice1 = make([]byte, 5)
+	slice2 = make([]*int, 5)
+	slice3 = make([][]byte, 5)
+}
+
+func makeInterface(v complex128) interface{} {
+	return v // always stored in an allocation
+}

compiler/testdata/gc.ll

@@ -0,0 +1,113 @@
+; ModuleID = 'gc.go'
+source_filename = "gc.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
+%runtime.interfaceMethodInfo = type { i8*, i32 }
+%runtime.funcValue = type { i8*, i32 }
+%runtime._interface = type { i32, i8* }
+
+@main.scalar1 = hidden global i8* null, align 4
+@main.scalar2 = hidden global i32* null, align 4
+@main.scalar3 = hidden global i64* null, align 4
+@main.scalar4 = hidden global float* null, align 4
+@main.array1 = hidden global [3 x i8]* null, align 4
+@main.array2 = hidden global [71 x i8]* null, align 4
+@main.array3 = hidden global [3 x i8*]* null, align 4
+@main.struct1 = hidden global {}* null, align 4
+@main.struct2 = hidden global { i32, i32 }* null, align 4
+@main.struct3 = hidden global { i8*, [60 x i32], i8* }* null, align 4
+@main.slice1 = hidden global { i8*, i32, i32 } zeroinitializer, align 8
+@main.slice2 = hidden global { i32**, i32, i32 } zeroinitializer, align 8
+@main.slice3 = hidden global { { i8*, i32, i32 }*, i32, i32 } zeroinitializer, align 8
+@"runtime/gc.layout:62-2000000000000001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c" \00\00\00\00\00\00\01" }
+@"reflect/types.type:basic:complex128" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* null, i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:basic:complex128", i32 0 }
+@"reflect/types.type:pointer:basic:complex128" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:complex128", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.newScalar(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %new = call i8* @runtime.alloc(i32 1, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  store i8* %new, i8** @main.scalar1, align 4
+  %new1 = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  store i8* %new1, i8** bitcast (i32** @main.scalar2 to i8**), align 4
+  %new2 = call i8* @runtime.alloc(i32 8, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  store i8* %new2, i8** bitcast (i64** @main.scalar3 to i8**), align 4
+  %new3 = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  store i8* %new3, i8** bitcast (float** @main.scalar4 to i8**), align 4
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.newArray(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %new = call i8* @runtime.alloc(i32 3, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  store i8* %new, i8** bitcast ([3 x i8]** @main.array1 to i8**), align 4
+  %new1 = call i8* @runtime.alloc(i32 71, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  store i8* %new1, i8** bitcast ([71 x i8]** @main.array2 to i8**), align 4
+  %new2 = call i8* @runtime.alloc(i32 12, i8* nonnull inttoptr (i32 67 to i8*), i8* undef, i8* null) #0
+  store i8* %new2, i8** bitcast ([3 x i8*]** @main.array3 to i8**), align 4
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.newStruct(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %new = call i8* @runtime.alloc(i32 0, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  store i8* %new, i8** bitcast ({}** @main.struct1 to i8**), align 4
+  %new1 = call i8* @runtime.alloc(i32 8, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  store i8* %new1, i8** bitcast ({ i32, i32 }** @main.struct2 to i8**), align 4
+  %new2 = call i8* @runtime.alloc(i32 248, i8* bitcast ({ i32, [8 x i8] }* @"runtime/gc.layout:62-2000000000000001" to i8*), i8* undef, i8* null) #0
+  store i8* %new2, i8** bitcast ({ i8*, [60 x i32], i8* }** @main.struct3 to i8**), align 4
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden %runtime.funcValue* @main.newFuncValue(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %new = call i8* @runtime.alloc(i32 8, i8* nonnull inttoptr (i32 197 to i8*), i8* undef, i8* null) #0
+  %0 = bitcast i8* %new to %runtime.funcValue*
+  ret %runtime.funcValue* %0
+}
+
+; Function Attrs: nounwind
+define hidden void @main.makeSlice(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %makeslice = call i8* @runtime.alloc(i32 5, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  store i8* %makeslice, i8** getelementptr inbounds ({ i8*, i32, i32 }, { i8*, i32, i32 }* @main.slice1, i32 0, i32 0), align 8
+  store i32 5, i32* getelementptr inbounds ({ i8*, i32, i32 }, { i8*, i32, i32 }* @main.slice1, i32 0, i32 1), align 4
+  store i32 5, i32* getelementptr inbounds ({ i8*, i32, i32 }, { i8*, i32, i32 }* @main.slice1, i32 0, i32 2), align 8
+  %makeslice1 = call i8* @runtime.alloc(i32 20, i8* nonnull inttoptr (i32 67 to i8*), i8* undef, i8* null) #0
+  store i8* %makeslice1, i8** bitcast ({ i32**, i32, i32 }* @main.slice2 to i8**), align 8
+  store i32 5, i32* getelementptr inbounds ({ i32**, i32, i32 }, { i32**, i32, i32 }* @main.slice2, i32 0, i32 1), align 4
+  store i32 5, i32* getelementptr inbounds ({ i32**, i32, i32 }, { i32**, i32, i32 }* @main.slice2, i32 0, i32 2), align 8
+  %makeslice3 = call i8* @runtime.alloc(i32 60, i8* nonnull inttoptr (i32 71 to i8*), i8* undef, i8* null) #0
+  store i8* %makeslice3, i8** bitcast ({ { i8*, i32, i32 }*, i32, i32 }* @main.slice3 to i8**), align 8
+  store i32 5, i32* getelementptr inbounds ({ { i8*, i32, i32 }*, i32, i32 }, { { i8*, i32, i32 }*, i32, i32 }* @main.slice3, i32 0, i32 1), align 4
+  store i32 5, i32* getelementptr inbounds ({ { i8*, i32, i32 }*, i32, i32 }, { { i8*, i32, i32 }*, i32, i32 }* @main.slice3, i32 0, i32 2), align 8
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden %runtime._interface @main.makeInterface(double %v.r, double %v.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef, i8* null) #0
+  %.repack = bitcast i8* %0 to double*
+  store double %v.r, double* %.repack, align 8
+  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
+  %1 = bitcast i8* %.repack1 to double*
+  store double %v.i, double* %1, align 8
+  %2 = insertvalue %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:complex128" to i32), i8* undef }, i8* %0, 1
+  ret %runtime._interface %2
+}
+
+attributes #0 = { nounwind }

compiler/testdata/go1.17.go

@@ -0,0 +1,41 @@
+package main
+
+// Test changes to the language introduced in Go 1.17.
+// For details, see: https://tip.golang.org/doc/go1.17#language
+// These tests should be merged into the regular slice tests once Go 1.17 is the
+// minimun Go version for TinyGo.
+
+import "unsafe"
+
+func Add32(p unsafe.Pointer, len int) unsafe.Pointer {
+	return unsafe.Add(p, len)
+}
+
+func Add64(p unsafe.Pointer, len int64) unsafe.Pointer {
+	return unsafe.Add(p, len)
+}
+
+func SliceToArray(s []int) *[4]int {
+	return (*[4]int)(s)
+}
+
+func SliceToArrayConst() *[4]int {
+	s := make([]int, 6)
+	return (*[4]int)(s)
+}
+
+func SliceInt(ptr *int, len int) []int {
+	return unsafe.Slice(ptr, len)
+}
+
+func SliceUint16(ptr *byte, len uint16) []byte {
+	return unsafe.Slice(ptr, len)
+}
+
+func SliceUint64(ptr *int, len uint64) []int {
+	return unsafe.Slice(ptr, len)
+}
+
+func SliceInt64(ptr *int, len int64) []int {
+	return unsafe.Slice(ptr, len)
+}

compiler/testdata/go1.17.ll

@@ -0,0 +1,147 @@
+; ModuleID = 'go1.17.go'
+source_filename = "go1.17.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden i8* @main.Add32(i8* %p, i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = getelementptr i8, i8* %p, i32 %len
+  ret i8* %0
+}
+
+; Function Attrs: nounwind
+define hidden i8* @main.Add64(i8* %p, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = trunc i64 %len to i32
+  %1 = getelementptr i8, i8* %p, i32 %0
+  ret i8* %1
+}
+
+; Function Attrs: nounwind
+define hidden [4 x i32]* @main.SliceToArray(i32* %s.data, i32 %s.len, i32 %s.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp ult i32 %s.len, 4
+  br i1 %0, label %slicetoarray.throw, label %slicetoarray.next
+
+slicetoarray.throw:                               ; preds = %entry
+  call void @runtime.sliceToArrayPointerPanic(i8* undef, i8* null) #0
+  unreachable
+
+slicetoarray.next:                                ; preds = %entry
+  %1 = bitcast i32* %s.data to [4 x i32]*
+  ret [4 x i32]* %1
+}
+
+declare void @runtime.sliceToArrayPointerPanic(i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden [4 x i32]* @main.SliceToArrayConst(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %makeslice = call i8* @runtime.alloc(i32 24, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  br i1 false, label %slicetoarray.throw, label %slicetoarray.next
+
+slicetoarray.throw:                               ; preds = %entry
+  unreachable
+
+slicetoarray.next:                                ; preds = %entry
+  %0 = bitcast i8* %makeslice to [4 x i32]*
+  ret [4 x i32]* %0
+}
+
+; Function Attrs: nounwind
+define hidden { i32*, i32, i32 } @main.SliceInt(i32* dereferenceable_or_null(4) %ptr, i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp ugt i32 %len, 1073741823
+  %1 = icmp eq i32* %ptr, null
+  %2 = icmp ne i32 %len, 0
+  %3 = and i1 %1, %2
+  %4 = or i1 %3, %0
+  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
+
+unsafe.Slice.throw:                               ; preds = %entry
+  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
+  unreachable
+
+unsafe.Slice.next:                                ; preds = %entry
+  %5 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
+  %6 = insertvalue { i32*, i32, i32 } %5, i32 %len, 1
+  %7 = insertvalue { i32*, i32, i32 } %6, i32 %len, 2
+  ret { i32*, i32, i32 } %7
+}
+
+declare void @runtime.unsafeSlicePanic(i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden { i8*, i32, i32 } @main.SliceUint16(i8* dereferenceable_or_null(1) %ptr, i16 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp eq i8* %ptr, null
+  %1 = icmp ne i16 %len, 0
+  %2 = and i1 %0, %1
+  br i1 %2, label %unsafe.Slice.throw, label %unsafe.Slice.next
+
+unsafe.Slice.throw:                               ; preds = %entry
+  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
+  unreachable
+
+unsafe.Slice.next:                                ; preds = %entry
+  %3 = zext i16 %len to i32
+  %4 = insertvalue { i8*, i32, i32 } undef, i8* %ptr, 0
+  %5 = insertvalue { i8*, i32, i32 } %4, i32 %3, 1
+  %6 = insertvalue { i8*, i32, i32 } %5, i32 %3, 2
+  ret { i8*, i32, i32 } %6
+}
+
+; Function Attrs: nounwind
+define hidden { i32*, i32, i32 } @main.SliceUint64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp ugt i64 %len, 1073741823
+  %1 = icmp eq i32* %ptr, null
+  %2 = icmp ne i64 %len, 0
+  %3 = and i1 %1, %2
+  %4 = or i1 %3, %0
+  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
+
+unsafe.Slice.throw:                               ; preds = %entry
+  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
+  unreachable
+
+unsafe.Slice.next:                                ; preds = %entry
+  %5 = trunc i64 %len to i32
+  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
+  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
+  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
+  ret { i32*, i32, i32 } %8
+}
+
+; Function Attrs: nounwind
+define hidden { i32*, i32, i32 } @main.SliceInt64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = icmp ugt i64 %len, 1073741823
+  %1 = icmp eq i32* %ptr, null
+  %2 = icmp ne i64 %len, 0
+  %3 = and i1 %1, %2
+  %4 = or i1 %3, %0
+  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
+
+unsafe.Slice.throw:                               ; preds = %entry
+  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
+  unreachable
+
+unsafe.Slice.next:                                ; preds = %entry
+  %5 = trunc i64 %len to i32
+  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
+  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
+  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
+  ret { i32*, i32, i32 } %8
+}
+
+attributes #0 = { nounwind }

compiler/testdata/goroutine-cortex-m-qemu.ll

@@ -0,0 +1,209 @@
+; ModuleID = 'goroutine.go'
+source_filename = "goroutine.go"
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "thumbv7m-unknown-unknown-eabi"
+
+%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
+%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
+%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
+%"internal/task.state" = type { i32, i32* }
+%runtime.chanSelectState = type { %runtime.channel*, i8* }
+
+@"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null) #0
+  ret void
+}
+
+declare void @main.regularFunction(i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #1 {
+entry:
+  %unpack.int = ptrtoint i8* %0 to i32
+  call void @main.regularFunction(i32 %unpack.int, i8* undef, i8* undef) #0
+  ret void
+}
+
+declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*, i8*)
+
+declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null) #0
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #2 {
+entry:
+  %unpack.int = ptrtoint i8* %0 to i32
+  call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, i8* undef, i8* undef)
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %n = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %0 = bitcast i8* %n to i32*
+  store i32 3, i32* %0, align 4
+  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
+  %2 = bitcast i8* %1 to i32*
+  store i32 5, i32* %2, align 4
+  %3 = getelementptr inbounds i8, i8* %1, i32 4
+  %4 = bitcast i8* %3 to i8**
+  store i8* %n, i8** %4, align 4
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef, i8* null) #0
+  %5 = load i32, i32* %0, align 4
+  call void @runtime.printint32(i32 %5, i8* undef, i8* null) #0
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %unpack.ptr = bitcast i8* %context to i32*
+  store i32 7, i32* %unpack.ptr, align 4
+  ret void
+}
+
+; Function Attrs: nounwind
+define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #3 {
+entry:
+  %1 = bitcast i8* %0 to i32*
+  %2 = load i32, i32* %1, align 4
+  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %4 = bitcast i8* %3 to i8**
+  %5 = load i8*, i8** %4, align 4
+  call void @"main.closureFunctionGoroutine$1"(i32 %2, i8* %5, i8* undef)
+  ret void
+}
+
+declare void @runtime.printint32(i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.funcGoroutine(i8* %fn.context, void ()* %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i8* @runtime.alloc(i32 12, i8* null, i8* undef, i8* null) #0
+  %1 = bitcast i8* %0 to i32*
+  store i32 5, i32* %1, align 4
+  %2 = getelementptr inbounds i8, i8* %0, i32 4
+  %3 = bitcast i8* %2 to i8**
+  store i8* %fn.context, i8** %3, align 4
+  %4 = getelementptr inbounds i8, i8* %0, i32 8
+  %5 = bitcast i8* %4 to void ()**
+  store void ()* %fn.funcptr, void ()** %5, align 4
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null) #0
+  ret void
+}
+
+; Function Attrs: nounwind
+define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #4 {
+entry:
+  %1 = bitcast i8* %0 to i32*
+  %2 = load i32, i32* %1, align 4
+  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %4 = bitcast i8* %3 to i8**
+  %5 = load i8*, i8** %4, align 4
+  %6 = getelementptr inbounds i8, i8* %0, i32 8
+  %7 = bitcast i8* %6 to void (i32, i8*, i8*)**
+  %8 = load void (i32, i8*, i8*)*, void (i32, i8*, i8*)** %7, align 4
+  call void %8(i32 %2, i8* %5, i8* undef) #0
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null) #0
+  ret void
+}
+
+declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null) #0
+  ret void
+}
+
+declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.startInterfaceMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef, i8* null) #0
+  %1 = bitcast i8* %0 to i8**
+  store i8* %itf.value, i8** %1, align 4
+  %2 = getelementptr inbounds i8, i8* %0, i32 4
+  %.repack = bitcast i8* %2 to i8**
+  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main$string", i32 0, i32 0), i8** %.repack, align 4
+  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
+  %3 = bitcast i8* %.repack1 to i32*
+  store i32 4, i32* %3, align 4
+  %4 = getelementptr inbounds i8, i8* %0, i32 12
+  %5 = bitcast i8* %4 to i32*
+  store i32 %itf.typecode, i32* %5, align 4
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null) #0
+  ret void
+}
+
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*, i8*) #5
+
+; Function Attrs: nounwind
+define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(i8* %0) unnamed_addr #6 {
+entry:
+  %1 = bitcast i8* %0 to i8**
+  %2 = load i8*, i8** %1, align 4
+  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %4 = bitcast i8* %3 to i8**
+  %5 = load i8*, i8** %4, align 4
+  %6 = getelementptr inbounds i8, i8* %0, i32 8
+  %7 = bitcast i8* %6 to i32*
+  %8 = load i32, i32* %7, align 4
+  %9 = getelementptr inbounds i8, i8* %0, i32 12
+  %10 = bitcast i8* %9 to i32*
+  %11 = load i32, i32* %10, align 4
+  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8* %2, i8* %5, i32 %8, i32 %11, i8* undef, i8* undef) #0
+  ret void
+}
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind "tinygo-gowrapper"="main.regularFunction" }
+attributes #2 = { nounwind "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
+attributes #3 = { nounwind "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
+attributes #4 = { nounwind "tinygo-gowrapper" }
+attributes #5 = { "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
+attributes #6 = { nounwind "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }

compiler/testdata/goroutine-wasm.ll

@@ -0,0 +1,141 @@
+; ModuleID = 'goroutine.go'
+source_filename = "goroutine.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+%runtime.funcValueWithSignature = type { i32, i8* }
+%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
+%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
+%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
+%"internal/task.state" = type { i8* }
+%runtime.chanSelectState = type { %runtime.channel*, i8* }
+
+@"main$pack" = internal unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
+@"main$pack.1" = internal unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
+@"reflect/types.funcid:func:{basic:int}{}" = external constant i8
+@"main.closureFunctionGoroutine$1$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }
+@"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @main.regularFunction to i32), i8* bitcast ({ i32, i8* }* @"main$pack" to i8*), i32 undef, i8* undef, i8* null) #0
+  ret void
+}
+
+declare void @main.regularFunction(i32, i8*, i8*)
+
+declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.inlineFunctionGoroutine$1" to i32), i8* bitcast ({ i32, i8* }* @"main$pack.1" to i8*), i32 undef, i8* undef, i8* null) #0
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %n = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %0 = bitcast i8* %n to i32*
+  store i32 3, i32* %0, align 4
+  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
+  %2 = bitcast i8* %1 to i32*
+  store i32 5, i32* %2, align 4
+  %3 = getelementptr inbounds i8, i8* %1, i32 4
+  %4 = bitcast i8* %3 to i8**
+  store i8* %n, i8** %4, align 4
+  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* nonnull %1, i32 undef, i8* undef, i8* null) #0
+  %5 = load i32, i32* %0, align 4
+  call void @runtime.printint32(i32 %5, i8* undef, i8* null) #0
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %unpack.ptr = bitcast i8* %context to i32*
+  store i32 7, i32* %unpack.ptr, align 4
+  ret void
+}
+
+declare void @runtime.printint32(i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.funcGoroutine(i8* %fn.context, i32 %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i32 @runtime.getFuncPtr(i8* %fn.context, i32 %fn.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null) #0
+  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
+  %2 = bitcast i8* %1 to i32*
+  store i32 5, i32* %2, align 4
+  %3 = getelementptr inbounds i8, i8* %1, i32 4
+  %4 = bitcast i8* %3 to i8**
+  store i8* %fn.context, i8** %4, align 4
+  call void @"internal/task.start"(i32 %0, i8* nonnull %1, i32 undef, i8* undef, i8* null) #0
+  ret void
+}
+
+declare i32 @runtime.getFuncPtr(i8*, i32, i8* dereferenceable_or_null(1), i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null) #0
+  ret void
+}
+
+declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null) #0
+  ret void
+}
+
+declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.startInterfaceMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef, i8* null) #0
+  %1 = bitcast i8* %0 to i8**
+  store i8* %itf.value, i8** %1, align 4
+  %2 = getelementptr inbounds i8, i8* %0, i32 4
+  %.repack = bitcast i8* %2 to i8**
+  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main$string", i32 0, i32 0), i8** %.repack, align 4
+  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
+  %3 = bitcast i8* %.repack1 to i32*
+  store i32 4, i32* %3, align 4
+  %4 = getelementptr inbounds i8, i8* %0, i32 12
+  %5 = bitcast i8* %4 to i32*
+  store i32 %itf.typecode, i32* %5, align 4
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*, i8*, i32, i32, i8*, i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke" to i32), i8* nonnull %0, i32 undef, i8* undef, i8* null) #0
+  ret void
+}
+
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*, i8*) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }

compiler/testdata/goroutine.go

@@ -0,0 +1,51 @@
+package main
+
+func regularFunctionGoroutine() {
+	go regularFunction(5)
+}
+
+func inlineFunctionGoroutine() {
+	go func(x int) {
+	}(5)
+}
+
+func closureFunctionGoroutine() {
+	n := 3
+	go func(x int) {
+		n = 7
+	}(5)
+	print(n) // note: this is racy (but good enough for this test)
+}
+
+func funcGoroutine(fn func(x int)) {
+	go fn(5)
+}
+
+func recoverBuiltinGoroutine() {
+	// This is a no-op.
+	go recover()
+}
+
+func copyBuiltinGoroutine(dst, src []byte) {
+	// This is not run in a goroutine. While this copy operation can indeed take
+	// some time (if there is a lot of data to copy), there is no race-free way
+	// to make use of the result so it's unlikely applications will make use of
+	// it. And doing it this way should be just within the Go specification.
+	go copy(dst, src)
+}
+
+func closeBuiltinGoroutine(ch chan int) {
+	// This builtin is executed directly, not in a goroutine.
+	// The observed behavior is the same.
+	go close(ch)
+}
+
+func regularFunction(x int)
+
+type simpleInterface interface {
+	Print(string)
+}
+
+func startInterfaceMethod(itf simpleInterface) {
+	go itf.Print("test")
+}

compiler/testdata/interface.go

@@ -0,0 +1,63 @@
+// This file tests interface types and interface builtins.
+
+package main
+
+// Test interface construction.
+
+func simpleType() interface{} {
+	return 0
+}
+
+func pointerType() interface{} {
+	// Pointers have an element type, in this case int.
+	var v *int
+	return v
+}
+
+func interfaceType() interface{} {
+	// Interfaces can exist in interfaces, but only indirectly (through
+	// pointers).
+	var v *error
+	return v
+}
+
+func anonymousInterfaceType() interface{} {
+	var v *interface {
+		String() string
+	}
+	return v
+}
+
+// Test interface builtins.
+
+func isInt(itf interface{}) bool {
+	_, ok := itf.(int)
+	return ok
+}
+
+func isError(itf interface{}) bool {
+	// Interface assert on (builtin) named interface type.
+	_, ok := itf.(error)
+	return ok
+}
+
+func isStringer(itf interface{}) bool {
+	// Interface assert on anonymous interface type.
+	_, ok := itf.(interface {
+		String() string
+	})
+	return ok
+}
+
+type fooInterface interface {
+	String() string
+	foo(int) byte
+}
+
+func callFooMethod(itf fooInterface) uint8 {
+	return itf.foo(3)
+}
+
+func callErrorMethod(itf error) string {
+	return itf.Error()
+}

compiler/testdata/interface.ll

@@ -0,0 +1,124 @@
+; ModuleID = 'interface.go'
+source_filename = "interface.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
+%runtime.interfaceMethodInfo = type { i8*, i32 }
+%runtime._interface = type { i32, i8* }
+%runtime._string = type { i8*, i32 }
+
+@"reflect/types.type:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* null, i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:basic:int", i32 0 }
+@"reflect/types.type:pointer:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
+@"reflect/types.type:pointer:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:named:error", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
+@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:named:error", i32 ptrtoint (i1 (i32)* @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
+@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{Error() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}", i32 ptrtoint (i1 (i32)* @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
+@"reflect/methods.Error() string" = linkonce_odr constant i8 0, align 1
+@"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
+@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
+@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{String:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
+@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{String() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", i32 ptrtoint (i1 (i32)* @"interface:{String:func:{}{basic:string}}.$typeassert" to i32) }
+@"reflect/methods.String() string" = linkonce_odr constant i8 0, align 1
+@"reflect/types.interface:interface{String() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.String() string"]
+@"reflect/types.typeid:basic:int" = external constant i8
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden %runtime._interface @main.simpleType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:int" to i32), i8* null }
+}
+
+; Function Attrs: nounwind
+define hidden %runtime._interface @main.pointerType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:basic:int" to i32), i8* null }
+}
+
+; Function Attrs: nounwind
+define hidden %runtime._interface @main.interfaceType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:named:error" to i32), i8* null }
+}
+
+declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32) #1
+
+; Function Attrs: nounwind
+define hidden %runtime._interface @main.anonymousInterfaceType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" to i32), i8* null }
+}
+
+declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32) #2
+
+; Function Attrs: nounwind
+define hidden i1 @main.isInt(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, i8* nonnull @"reflect/types.typeid:basic:int", i8* undef, i8* null) #0
+  br i1 %typecode, label %typeassert.ok, label %typeassert.next
+
+typeassert.ok:                                    ; preds = %entry
+  br label %typeassert.next
+
+typeassert.next:                                  ; preds = %typeassert.ok, %entry
+  ret i1 %typecode
+}
+
+declare i1 @runtime.typeAssert(i32, i8* dereferenceable_or_null(1), i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden i1 @main.isError(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
+  br i1 %0, label %typeassert.ok, label %typeassert.next
+
+typeassert.ok:                                    ; preds = %entry
+  br label %typeassert.next
+
+typeassert.next:                                  ; preds = %typeassert.ok, %entry
+  ret i1 %0
+}
+
+; Function Attrs: nounwind
+define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
+  br i1 %0, label %typeassert.ok, label %typeassert.next
+
+typeassert.ok:                                    ; preds = %entry
+  br label %typeassert.next
+
+typeassert.next:                                  ; preds = %typeassert.ok, %entry
+  ret i1 %0
+}
+
+; Function Attrs: nounwind
+define hidden i8 @main.callFooMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(i8* %itf.value, i32 3, i32 %itf.typecode, i8* undef, i8* undef) #0
+  ret i8 %0
+}
+
+declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(i8*, i32, i32, i8*, i8*) #3
+
+; Function Attrs: nounwind
+define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8* %itf.value, i32 %itf.typecode, i8* undef, i8* undef) #0
+  ret %runtime._string %0
+}
+
+declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8*, i32, i8*, i8*) #4
+
+attributes #0 = { nounwind }
+attributes #1 = { "tinygo-methods"="reflect/methods.Error() string" }
+attributes #2 = { "tinygo-methods"="reflect/methods.String() string" }
+attributes #3 = { "tinygo-invoke"="main.$methods.foo(int) byte" "tinygo-methods"="reflect/methods.String() string; main.$methods.foo(int) byte" }
+attributes #4 = { "tinygo-invoke"="reflect/methods.Error() string" "tinygo-methods"="reflect/methods.Error() string" }

compiler/testdata/intrinsics-cortex-m-qemu.ll

@@ -0,0 +1,32 @@
+; ModuleID = 'intrinsics.go'
+source_filename = "intrinsics.go"
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "thumbv7m-unknown-unknown-eabi"
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden double @main.mySqrt(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call double @math.Sqrt(double %x, i8* undef, i8* undef) #0
+  ret double %0
+}
+
+declare double @math.Sqrt(double, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden double @main.myTrunc(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call double @math.Trunc(double %x, i8* undef, i8* undef) #0
+  ret double %0
+}
+
+declare double @math.Trunc(double, i8*, i8*)
+
+attributes #0 = { nounwind }

compiler/testdata/intrinsics-wasm.ll

@@ -0,0 +1,35 @@
+; ModuleID = 'intrinsics.go'
+source_filename = "intrinsics.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden double @main.mySqrt(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call double @llvm.sqrt.f64(double %x)
+  ret double %0
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare double @llvm.sqrt.f64(double) #1
+
+; Function Attrs: nounwind
+define hidden double @main.myTrunc(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call double @llvm.trunc.f64(double %x)
+  ret double %0
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare double @llvm.trunc.f64(double) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone speculatable willreturn }

compiler/testdata/intrinsics.go

@@ -0,0 +1,14 @@
+package main
+
+// Test how intrinsics are lowered: either as regular calls to the math
+// functions or as LLVM builtins (such as llvm.sqrt.f64).
+
+import "math"
+
+func mySqrt(x float64) float64 {
+	return math.Sqrt(x)
+}
+
+func myTrunc(x float64) float64 {
+	return math.Trunc(x)
+}

compiler/testdata/pointer.go

@@ -0,0 +1,41 @@
+package main
+
+// This file tests various operations on pointers, such as pointer arithmetic
+// and dereferencing pointers.
+
+import "unsafe"
+
+// Dereference pointers.
+
+func pointerDerefZero(x *[0]int) [0]int {
+	return *x // This is a no-op, there is nothing to load.
+}
+
+// Unsafe pointer casts, they are sometimes a no-op.
+
+func pointerCastFromUnsafe(x unsafe.Pointer) *int {
+	return (*int)(x)
+}
+
+func pointerCastToUnsafe(x *int) unsafe.Pointer {
+	return unsafe.Pointer(x)
+}
+
+func pointerCastToUnsafeNoop(x *byte) unsafe.Pointer {
+	return unsafe.Pointer(x)
+}
+
+// The compiler has support for a few special cast+add patterns that are
+// transformed into a single GEP.
+
+func pointerUnsafeGEPFixedOffset(ptr *byte) *byte {
+	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) + 10))
+}
+
+func pointerUnsafeGEPByteOffset(ptr *byte, offset uintptr) *byte {
+	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) + offset))
+}
+
+func pointerUnsafeGEPIntOffset(ptr *int32, offset uintptr) *int32 {
+	return (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) + offset*4))
+}

compiler/testdata/pointer.ll

@@ -0,0 +1,61 @@
+; ModuleID = 'pointer.go'
+source_filename = "pointer.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret [0 x i32] zeroinitializer
+}
+
+; Function Attrs: nounwind
+define hidden i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = bitcast i8* %x to i32*
+  ret i32* %0
+}
+
+; Function Attrs: nounwind
+define hidden i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = bitcast i32* %x to i8*
+  ret i8* %0
+}
+
+; Function Attrs: nounwind
+define hidden i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret i8* %x
+}
+
+; Function Attrs: nounwind
+define hidden i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = getelementptr inbounds i8, i8* %ptr, i32 10
+  ret i8* %0
+}
+
+; Function Attrs: nounwind
+define hidden i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = getelementptr inbounds i8, i8* %ptr, i32 %offset
+  ret i8* %0
+}
+
+; Function Attrs: nounwind
+define hidden i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = getelementptr i32, i32* %ptr, i32 %offset
+  ret i32* %0
+}
+
+attributes #0 = { nounwind }

compiler/testdata/pragma.go

@@ -0,0 +1,66 @@
+package main
+
+import _ "unsafe"
+
+// Creates an external global with name extern_global.
+//go:extern extern_global
+var externGlobal [0]byte
+
+// Creates a
+//go:align 32
+var alignedGlobal [4]uint32
+
+// Test conflicting pragmas (the last one counts).
+//go:align 64
+//go:align 16
+var alignedGlobal16 [4]uint32
+
+// Test exported functions.
+//export extern_func
+func externFunc() {
+}
+
+// Define a function in a different package using go:linkname.
+//go:linkname withLinkageName1 somepkg.someFunction1
+func withLinkageName1() {
+}
+
+// Import a function from a different package using go:linkname.
+//go:linkname withLinkageName2 somepkg.someFunction2
+func withLinkageName2()
+
+// Function has an 'inline hint', similar to the inline keyword in C.
+//go:inline
+func inlineFunc() {
+}
+
+// Function should never be inlined, equivalent to GCC
+// __attribute__((noinline)).
+//go:noinline
+func noinlineFunc() {
+}
+
+// This function should have the specified section.
+//go:section .special_function_section
+func functionInSection() {
+}
+
+//export exportedFunctionInSection
+//go:section .special_function_section
+func exportedFunctionInSection() {
+}
+
+// This function should not: it's only a declaration and not a definition.
+//go:section .special_function_section
+func undefinedFunctionNotInSection()
+
+//go:section .special_global_section
+var globalInSection uint32
+
+//go:section .special_global_section
+//go:extern undefinedGlobalNotInSection
+var undefinedGlobalNotInSection uint32
+
+//go:align 1024
+//go:section .global_section
+var multipleGlobalPragmas uint32

compiler/testdata/pragma.ll

@@ -0,0 +1,65 @@
+; ModuleID = 'pragma.go'
+source_filename = "pragma.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+@extern_global = external global [0 x i8], align 1
+@main.alignedGlobal = hidden global [4 x i32] zeroinitializer, align 32
+@main.alignedGlobal16 = hidden global [4 x i32] zeroinitializer, align 16
+@main.globalInSection = hidden global i32 0, section ".special_global_section", align 4
+@undefinedGlobalNotInSection = external global i32, align 4
+@main.multipleGlobalPragmas = hidden global i32 0, section ".global_section", align 1024
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define void @extern_func() #1 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @somepkg.someFunction1(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+declare void @somepkg.someFunction2(i8*, i8*)
+
+; Function Attrs: inlinehint nounwind
+define hidden void @main.inlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #2 {
+entry:
+  ret void
+}
+
+; Function Attrs: noinline nounwind
+define hidden void @main.noinlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #3 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.functionInSection(i8* %context, i8* %parentHandle) unnamed_addr #0 section ".special_function_section" {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define void @exportedFunctionInSection() #4 section ".special_function_section" {
+entry:
+  ret void
+}
+
+declare void @main.undefinedFunctionNotInSection(i8*, i8*)
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind "wasm-export-name"="extern_func" }
+attributes #2 = { inlinehint nounwind }
+attributes #3 = { noinline nounwind }
+attributes #4 = { nounwind "wasm-export-name"="exportedFunctionInSection" }

compiler/testdata/slice.go

@@ -0,0 +1,43 @@
+package main
+
+func sliceLen(ints []int) int {
+	return len(ints)
+}
+
+func sliceCap(ints []int) int {
+	return cap(ints)
+}
+
+func sliceElement(ints []int, index int) int {
+	return ints[index]
+}
+
+func sliceAppendValues(ints []int) []int {
+	return append(ints, 1, 2, 3)
+}
+
+func sliceAppendSlice(ints, added []int) []int {
+	return append(ints, added...)
+}
+
+func sliceCopy(dst, src []int) int {
+	return copy(dst, src)
+}
+
+// Test bounds checking in *ssa.MakeSlice instruction.
+
+func makeByteSlice(len int) []byte {
+	return make([]byte, len)
+}
+
+func makeInt16Slice(len int) []int16 {
+	return make([]int16, len)
+}
+
+func makeArraySlice(len int) [][3]byte {
+	return make([][3]byte, len) // slice with element size of 3
+}
+
+func makeInt32Slice(len int) []int32 {
+	return make([]int32, len)
+}

compiler/testdata/slice.ll

@@ -0,0 +1,177 @@
+; ModuleID = 'slice.go'
+source_filename = "slice.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret i32 %ints.len
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret i32 %ints.cap
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.sliceElement(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %.not = icmp ult i32 %index, %ints.len
+  br i1 %.not, label %lookup.next, label %lookup.throw
+
+lookup.throw:                                     ; preds = %entry
+  call void @runtime.lookupPanic(i8* undef, i8* null) #0
+  unreachable
+
+lookup.next:                                      ; preds = %entry
+  %0 = getelementptr inbounds i32, i32* %ints.data, i32 %index
+  %1 = load i32, i32* %0, align 4
+  ret i32 %1
+}
+
+declare void @runtime.lookupPanic(i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden { i32*, i32, i32 } @main.sliceAppendValues(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %varargs = call i8* @runtime.alloc(i32 12, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %0 = bitcast i8* %varargs to i32*
+  store i32 1, i32* %0, align 4
+  %1 = getelementptr inbounds i8, i8* %varargs, i32 4
+  %2 = bitcast i8* %1 to i32*
+  store i32 2, i32* %2, align 4
+  %3 = getelementptr inbounds i8, i8* %varargs, i32 8
+  %4 = bitcast i8* %3 to i32*
+  store i32 3, i32* %4, align 4
+  %append.srcPtr = bitcast i32* %ints.data to i8*
+  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, i8* undef, i8* null) #0
+  %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
+  %append.newBuf = bitcast i8* %append.newPtr to i32*
+  %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
+  %append.newCap = extractvalue { i8*, i32, i32 } %append.new, 2
+  %5 = insertvalue { i32*, i32, i32 } undef, i32* %append.newBuf, 0
+  %6 = insertvalue { i32*, i32, i32 } %5, i32 %append.newLen, 1
+  %7 = insertvalue { i32*, i32, i32 } %6, i32 %append.newCap, 2
+  ret { i32*, i32, i32 } %7
+}
+
+declare { i8*, i32, i32 } @runtime.sliceAppend(i8*, i8* nocapture readonly, i32, i32, i32, i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden { i32*, i32, i32 } @main.sliceAppendSlice(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32* %added.data, i32 %added.len, i32 %added.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %append.srcPtr = bitcast i32* %ints.data to i8*
+  %append.srcPtr1 = bitcast i32* %added.data to i8*
+  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* %append.srcPtr1, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, i8* undef, i8* null) #0
+  %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
+  %append.newBuf = bitcast i8* %append.newPtr to i32*
+  %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
+  %append.newCap = extractvalue { i8*, i32, i32 } %append.new, 2
+  %0 = insertvalue { i32*, i32, i32 } undef, i32* %append.newBuf, 0
+  %1 = insertvalue { i32*, i32, i32 } %0, i32 %append.newLen, 1
+  %2 = insertvalue { i32*, i32, i32 } %1, i32 %append.newCap, 2
+  ret { i32*, i32, i32 } %2
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.sliceCopy(i32* %dst.data, i32 %dst.len, i32 %dst.cap, i32* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %copy.dstPtr = bitcast i32* %dst.data to i8*
+  %copy.srcPtr = bitcast i32* %src.data to i8*
+  %copy.n = call i32 @runtime.sliceCopy(i8* %copy.dstPtr, i8* %copy.srcPtr, i32 %dst.len, i32 %src.len, i32 4, i8* undef, i8* null) #0
+  ret i32 %copy.n
+}
+
+declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden { i8*, i32, i32 } @main.makeByteSlice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %slice.maxcap = icmp slt i32 %len, 0
+  br i1 %slice.maxcap, label %slice.throw, label %slice.next
+
+slice.throw:                                      ; preds = %entry
+  call void @runtime.slicePanic(i8* undef, i8* null) #0
+  unreachable
+
+slice.next:                                       ; preds = %entry
+  %makeslice.buf = call i8* @runtime.alloc(i32 %len, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %0 = insertvalue { i8*, i32, i32 } undef, i8* %makeslice.buf, 0
+  %1 = insertvalue { i8*, i32, i32 } %0, i32 %len, 1
+  %2 = insertvalue { i8*, i32, i32 } %1, i32 %len, 2
+  ret { i8*, i32, i32 } %2
+}
+
+declare void @runtime.slicePanic(i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden { i16*, i32, i32 } @main.makeInt16Slice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %slice.maxcap = icmp slt i32 %len, 0
+  br i1 %slice.maxcap, label %slice.throw, label %slice.next
+
+slice.throw:                                      ; preds = %entry
+  call void @runtime.slicePanic(i8* undef, i8* null) #0
+  unreachable
+
+slice.next:                                       ; preds = %entry
+  %makeslice.cap = shl i32 %len, 1
+  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %makeslice.array = bitcast i8* %makeslice.buf to i16*
+  %0 = insertvalue { i16*, i32, i32 } undef, i16* %makeslice.array, 0
+  %1 = insertvalue { i16*, i32, i32 } %0, i32 %len, 1
+  %2 = insertvalue { i16*, i32, i32 } %1, i32 %len, 2
+  ret { i16*, i32, i32 } %2
+}
+
+; Function Attrs: nounwind
+define hidden { [3 x i8]*, i32, i32 } @main.makeArraySlice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %slice.maxcap = icmp ugt i32 %len, 1431655765
+  br i1 %slice.maxcap, label %slice.throw, label %slice.next
+
+slice.throw:                                      ; preds = %entry
+  call void @runtime.slicePanic(i8* undef, i8* null) #0
+  unreachable
+
+slice.next:                                       ; preds = %entry
+  %makeslice.cap = mul i32 %len, 3
+  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %makeslice.array = bitcast i8* %makeslice.buf to [3 x i8]*
+  %0 = insertvalue { [3 x i8]*, i32, i32 } undef, [3 x i8]* %makeslice.array, 0
+  %1 = insertvalue { [3 x i8]*, i32, i32 } %0, i32 %len, 1
+  %2 = insertvalue { [3 x i8]*, i32, i32 } %1, i32 %len, 2
+  ret { [3 x i8]*, i32, i32 } %2
+}
+
+; Function Attrs: nounwind
+define hidden { i32*, i32, i32 } @main.makeInt32Slice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %slice.maxcap = icmp ugt i32 %len, 1073741823
+  br i1 %slice.maxcap, label %slice.throw, label %slice.next
+
+slice.throw:                                      ; preds = %entry
+  call void @runtime.slicePanic(i8* undef, i8* null) #0
+  unreachable
+
+slice.next:                                       ; preds = %entry
+  %makeslice.cap = shl i32 %len, 2
+  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %makeslice.array = bitcast i8* %makeslice.buf to i32*
+  %0 = insertvalue { i32*, i32, i32 } undef, i32* %makeslice.array, 0
+  %1 = insertvalue { i32*, i32, i32 } %0, i32 %len, 1
+  %2 = insertvalue { i32*, i32, i32 } %1, i32 %len, 2
+  ret { i32*, i32, i32 } %2
+}
+
+attributes #0 = { nounwind }

compiler/testdata/string.go

@@ -0,0 +1,29 @@
+package main
+
+func someString() string {
+	return "foo"
+}
+
+func zeroLengthString() string {
+	return ""
+}
+
+func stringLen(s string) int {
+	return len(s)
+}
+
+func stringIndex(s string, index int) byte {
+	return s[index]
+}
+
+func stringCompareEqual(s1, s2 string) bool {
+	return s1 == s2
+}
+
+func stringCompareUnequal(s1, s2 string) bool {
+	return s1 != s2
+}
+
+func stringCompareLarger(s1, s2 string) bool {
+	return s1 > s2
+}

compiler/testdata/string.ll

@@ -0,0 +1,81 @@
+; ModuleID = 'string.go'
+source_filename = "string.go"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-wasi"
+
+%runtime._string = type { i8*, i32 }
+
+@"main$string" = internal unnamed_addr constant [3 x i8] c"foo", align 1
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden %runtime._string @main.someString(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret %runtime._string { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @"main$string", i32 0, i32 0), i32 3 }
+}
+
+; Function Attrs: nounwind
+define hidden %runtime._string @main.zeroLengthString(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret %runtime._string zeroinitializer
+}
+
+; Function Attrs: nounwind
+define hidden i32 @main.stringLen(i8* %s.data, i32 %s.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  ret i32 %s.len
+}
+
+; Function Attrs: nounwind
+define hidden i8 @main.stringIndex(i8* %s.data, i32 %s.len, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %.not = icmp ult i32 %index, %s.len
+  br i1 %.not, label %lookup.next, label %lookup.throw
+
+lookup.throw:                                     ; preds = %entry
+  call void @runtime.lookupPanic(i8* undef, i8* null) #0
+  unreachable
+
+lookup.next:                                      ; preds = %entry
+  %0 = getelementptr inbounds i8, i8* %s.data, i32 %index
+  %1 = load i8, i8* %0, align 1
+  ret i8 %1
+}
+
+declare void @runtime.lookupPanic(i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden i1 @main.stringCompareEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null) #0
+  ret i1 %0
+}
+
+declare i1 @runtime.stringEqual(i8*, i32, i8*, i32, i8*, i8*)
+
+; Function Attrs: nounwind
+define hidden i1 @main.stringCompareUnequal(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null) #0
+  %1 = xor i1 %0, true
+  ret i1 %1
+}
+
+; Function Attrs: nounwind
+define hidden i1 @main.stringCompareLarger(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+entry:
+  %0 = call i1 @runtime.stringLess(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null) #0
+  %1 = xor i1 %0, true
+  ret i1 %1
+}
+
+declare i1 @runtime.stringLess(i8*, i32, i8*, i32, i8*, i8*)
+
+attributes #0 = { nounwind }

go.mod

@@ -1,14 +1,17 @@
 module github.com/tinygo-org/tinygo
 
-go 1.11
+go 1.15
 
 require (
+	github.com/aykevl/go-wasm v0.0.2-0.20211030161413-11881cb9032d // indirect
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
-	github.com/chromedp/cdproto v0.0.0-20200709115526-d1f6fc58448b
-	github.com/chromedp/chromedp v0.5.4-0.20200303084119-2bb39134ab9e
+	github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693
+	github.com/chromedp/chromedp v0.6.4
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
 	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
-	go.bug.st/serial v1.0.0
-	golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2
-	tinygo.org/x/go-llvm v0.0.0-20201104183921-570e7a6841d9
+	github.com/mattn/go-colorable v0.1.8
+	go.bug.st/serial v1.1.3
+	golang.org/x/sys v0.0.0-20210510120138-977fb7262007
+	golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9
+	tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c
 )

go.sum

@@ -1,52 +1,74 @@
+github.com/aykevl/go-wasm v0.0.2-0.20211030161413-11881cb9032d h1:JeuI5/546naK5hpOIX+Lq5xE8rvt7uwiTp6iL+pLQgk=
+github.com/aykevl/go-wasm v0.0.2-0.20211030161413-11881cb9032d/go.mod h1:7sXyiaA0WtSogCu67R2252fQpVmJMh9JWJ9ddtGkpWw=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2 h1:oMCHnXa6CCCafdPDbMh/lWRhRByN0VFLvv+g+ayx1SI=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI=
-github.com/chromedp/cdproto v0.0.0-20200116234248-4da64dd111ac/go.mod h1:PfAWWKJqjlGFYJEidUM6aVIWPr0EpobeyVWEEmplX7g=
-github.com/chromedp/cdproto v0.0.0-20200709115526-d1f6fc58448b h1:LF+GRwyzxrO3MUzPvejv+yBup0lNG+/QdIRrkxOPseA=
-github.com/chromedp/cdproto v0.0.0-20200709115526-d1f6fc58448b/go.mod h1:E6LPWRdIJc11h/di5p0rwvRmUYbhGpBEH7ZbPfzDIOE=
-github.com/chromedp/chromedp v0.5.4-0.20200303084119-2bb39134ab9e h1:Hv0JVyHhbIXb9NiYQe4NsrfgrSofAp0q2FnhhJOXgi8=
-github.com/chromedp/chromedp v0.5.4-0.20200303084119-2bb39134ab9e/go.mod h1:vmQMRHFZrY3T+Jv51T0n87OK/i6bK+5P9a+Fg5jPwgQ=
-github.com/creack/goselect v0.1.1 h1:tiSSgKE1eJtxs1h/VgGQWuXUP0YS4CDIFMp6vaI1ls0=
-github.com/creack/goselect v0.1.1/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
+github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693 h1:11eq/RkpaotwdF6b1TRMcdgQUPNmyFEJOB7zLvh0O/Y=
+github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693/go.mod h1:55pim6Ht4LJKdVLlyFJV/g++HsEA1hQxPbB5JyNdZC0=
+github.com/chromedp/chromedp v0.6.4 h1:Gx7ZkRyrSVmbbDDja/ieNgNGJIvElroPOyeqYQGVDSY=
+github.com/chromedp/chromedp v0.6.4/go.mod h1:vodUdJf5dF/b8n0UBJv6NeM/QK28RjP3j+eM7fq4+84=
+github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
+github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
+github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0=
+github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
-github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.3 h1:ZOigqf7iBxkA4jdQ3am7ATzdlOFp9YzA6NmuvEEZc9g=
-github.com/gobwas/ws v1.0.3/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
+github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
+github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
+github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
+github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.0.4 h1:5eXU1CZhpQdq5kXbKb+sECH5Ia5KiO6CYzIzdlVx6Bs=
+github.com/gobwas/ws v1.0.4/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf h1:7+FW5aGwISbqUtkfmIpZJGRgNFg2ioYPvFaUxdqpDsg=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf/go.mod h1:RpwtwJQFrIEPstU94h88MWPXP2ektJZ8cZ0YntAmXiE=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08 h1:V0an7KRw92wmJysvFvtqtKMAPmvS5O0jtB0nYo6t+gs=
-github.com/knq/sysutil v0.0.0-20191005231841-15668db23d08/go.mod h1:dFWs1zEqDjFtnBXsd1vPOZaLsESovai349994nHx3e0=
-github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
-github.com/mailru/easyjson v0.7.1 h1:mdxE1MF9o53iCb2Ghj1VfWvh7ZOwHpnVG/xwXrV90U8=
-github.com/mailru/easyjson v0.7.1/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
+github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
+github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/mailru/easyjson v0.7.6 h1:8yTIVnZgCoiM1TgqoeTl+LfU5Jg6/xL3QhGQnimLYnA=
+github.com/mailru/easyjson v0.7.6/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892 h1:6J+qramlHVLmiBOgRiBOnQkno8uprqG6YFFQTt6uYIw=
 github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892/go.mod h1:Pb6XcsXyropB9LNHhnqaknG/vEwYztLkQzVCHv8sQ3M=
+github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-go.bug.st/serial v1.0.0 h1:ogEPzrllCsnG00EqKRjeYvPRsO7NJW6DqykzkdD6E/k=
-go.bug.st/serial v1.0.0/go.mod h1:rpXPISGjuNjPTRTcMlxi9lN6LoIPxd1ixVjBd8aSk/Q=
+github.com/yuin/goldmark v1.3.5 h1:dPmz1Snjq0kmkz159iL7S6WzdahUTHnHB5M56WFVifs=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+go.bug.st/serial v1.1.3 h1:YEBxJa9pKS9Wdg46B/jiaKbvvbUrjhZZZITfJHEJhaE=
+go.bug.st/serial v1.1.3/go.mod h1:8TT7u/SwwNIpJ8QaG4s+HTjFt9ReXs2cdOU7ZEk50Dk=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee h1:WG0RUwxtNT4qqaXX3DPA8zHFNm/D9xaBpxzHt1WcA/E=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 h1:ZBzSG/7F4eNKz2L3GE9o300RX0Az1Bw5HF7PDraD+qU=
-golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2 h1:0sfSpGSa544Fwnbot3Oxq/U6SXqjty6Jy/3wRhVS7ig=
-golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9 h1:nvvuMxmx1q0gfRki3T0hjG8EwAcVCs91oWAXvyt4zhI=
+golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-tinygo.org/x/go-llvm v0.0.0-20201104183921-570e7a6841d9 h1:l2kTQOhqEoeDTK3ckUnwReOQwMPUmURMIdjJbeAuDT4=
-tinygo.org/x/go-llvm v0.0.0-20201104183921-570e7a6841d9/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20210308112806-9ef958b6bed4 h1:CMUHxVTb+UuUePuMf8vkWjZ3gTp9BBK91KrgOCwoNHs=
+tinygo.org/x/go-llvm v0.0.0-20210308112806-9ef958b6bed4/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c h1:vn9IPshzYmzZis10UEVrsIBRv9FpykADw6M3/tHHROg=
+tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=

goenv/goenv.go

@@ -142,10 +142,11 @@ func getHomeDir() string {
 // getGoroot returns an appropriate GOROOT from various sources. If it can't be
 // found, it returns an empty string.
 func getGoroot() string {
+	// An explicitly set GOROOT always has preference.
 	goroot := os.Getenv("GOROOT")
 	if goroot != "" {
-		// An explicitly set GOROOT always has preference.
-		return goroot
+		// Convert to the standard GOROOT being referenced, if it's a TinyGo cache.
+		return getStandardGoroot(goroot)
 	}
 
 	// Check for the location of the 'go' binary and base GOROOT on that.
@@ -170,8 +171,9 @@ func getGoroot() string {
 	switch runtime.GOOS {
 	case "linux":
 		candidates = []string{
-			"/usr/local/go", // manually installed
-			"/usr/lib/go",   // from the distribution
+			"/usr/local/go",     // manually installed
+			"/usr/lib/go",       // from the distribution
+			"/snap/go/current/", // installed using snap
 		}
 	case "darwin":
 		candidates = []string{
@@ -195,3 +197,21 @@ func isGoroot(goroot string) bool {
 	_, err := os.Stat(filepath.Join(goroot, "src", "runtime", "internal", "sys", "zversion.go"))
 	return err == nil
 }
+
+// getStandardGoroot returns the physical path to a real, standard Go GOROOT
+// implied by the given path.
+// If the given path appears to be a TinyGo cached GOROOT, it returns the path
+// referenced by symlinks contained in the cache. Otherwise, it returns the
+// given path as-is.
+func getStandardGoroot(path string) string {
+	// Check if the "bin" subdirectory of our given GOROOT is a symlink, and then
+	// return the _parent_ directory of its destination.
+	if dest, err := os.Readlink(filepath.Join(path, "bin")); nil == err {
+		// Clean the destination to remove any trailing slashes, so that
+		// filepath.Dir will always return the parent.
+		//   (because both "/foo" and "/foo/" are valid symlink destinations,
+		//   but filepath.Dir would return "/" and "/foo", respectively)
+		return filepath.Dir(filepath.Clean(dest))
+	}
+	return path
+}