interp: do not rely on fixed type names

After merging multiple LLVM modules into one, types may have been renamed. Therefore, the interp package should not rely on types to have any particular name.
compiler: include type information about the runtime in the compiler
2026-07-26 22:58:41 +00:00 · 2020-05-03 15:43:45 +02:00 · 2020-05-03 15:43:45 +02:00 · 2020-05-03 15:43:45 +02:00 · 2020-05-03 15:43:45 +02:00 · 2020-05-03 15:43:44 +02:00
1009 changed files with 16882 additions and 74291 deletions
@@ -6,53 +6,61 @@ commands:
      - run:
          name: "Pull submodules"
          command: git submodule update --init
-  install-xtensa-toolchain:
+  apt-dependencies:
    parameters:
-      variant:
+      llvm:
        type: string
    steps:
      - run:
-          name: "Install Xtensa toolchain"
+          name: "Install apt dependencies"
          command: |
-            curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz
-            sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz
-            sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-            rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz
+            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 \
+                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
+  install-node:
+    steps:
+      - run:
+          name: "Install node.js"
+          command: |
+            wget https://nodejs.org/dist/v10.15.1/node-v10.15.1-linux-x64.tar.xz
+            sudo tar -C /usr/local -xf node-v10.15.1-linux-x64.tar.xz
+            sudo ln -s /usr/local/node-v10.15.1-linux-x64/bin/node /usr/bin/node
+            rm node-v10.15.1-linux-x64.tar.xz
  llvm-source-linux:
    steps:
      - restore_cache:
          keys:
-            - llvm-source-13-v1
+            - llvm-source-10-v0
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-13-v1
+          key: llvm-source-10-v0
          paths:
-            - llvm-project/clang/lib/Headers
-            - llvm-project/clang/include
-            - llvm-project/lld/include
-            - llvm-project/llvm/include
-  hack-ninja-jobs:
-    steps:
-      - run:
-          name: "Hack Ninja to use less jobs"
-          command: |
-            echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
-            chmod +x /go/bin/ninja
-  build-binaryen-linux:
+            - llvm-project
+  build-wasi-libc:
    steps:
      - restore_cache:
          keys:
-            - binaryen-linux-v1
+            - wasi-libc-sysroot-v2
      - run:
-          name: "Build Binaryen"
-          command: |
-            make binaryen
+          name: "Build wasi-libc"
+          command: make wasi-libc
      - save_cache:
-          key: binaryen-linux-v1
+          key: wasi-libc-sysroot-v2
          paths:
-            - build/wasm-opt
+            - lib/wasi-libc/sysroot
  test-linux:
    parameters:
      llvm:
@@ -60,23 +68,9 @@ commands:
    steps:
      - checkout
      - submodules
-      - run:
-          name: "Install apt dependencies"
-          command: |
-            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 --no-install-recommends \
-                llvm-<<parameters.llvm>>-dev \
-                clang-<<parameters.llvm>> \
-                libclang-<<parameters.llvm>>-dev \
-                lld-<<parameters.llvm>> \
-                gcc-avr \
-                avr-libc \
-                cmake \
-                ninja-build
-      - hack-ninja-jobs
-      - build-binaryen-linux
+      - apt-dependencies:
+          llvm: "<<parameters.llvm>>"
+      - install-node
      - restore_cache:
          keys:
            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
@@ -85,37 +79,286 @@ commands:
      - run: go install -tags=llvm<<parameters.llvm>> .
      - restore_cache:
          keys:
-            - wasi-libc-sysroot-systemclang-v3
+            - wasi-libc-sysroot-systemclang-v1
      - run: make wasi-libc
      - save_cache:
-          key: wasi-libc-sysroot-systemclang-v3
+          key: wasi-libc-sysroot-systemclang-v1
          paths:
            - lib/wasi-libc/sysroot
+      - run: go test -v -tags=llvm<<parameters.llvm>> ./cgo ./compileopts ./compiler ./interp ./transform .
      - run: make gen-device -j4
-      - run: make smoketest XTENSA=0
+      - run: make smoketest
      - save_cache:
          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
          paths:
            - ~/.cache/go-build
+            - ~/.cache/tinygo
            - /go/pkg/mod
      - run: make fmt-check
+  assert-test-linux:
+    steps:
+      - checkout
+      - submodules
+      - run:
+          name: "Install apt dependencies"
+          command: |
+            sudo apt-get install \
+                gcc-arm-linux-gnueabihf \
+                binutils-arm-none-eabi \
+                libc6-dev-armel-cross \
+                gcc-aarch64-linux-gnu \
+                libc6-dev-arm64-cross \
+                qemu-system-arm \
+                qemu-user \
+                gcc-avr \
+                avr-libc
+      - install-node
+      - restore_cache:
+          keys:
+            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-v2-{{ checksum "go.mod" }}
+      - llvm-source-linux
+      - restore_cache:
+          keys:
+            - llvm-build-10-linux-v0-assert
+      - run:
+          name: "Build LLVM"
+          command: |
+            if [ ! -f llvm-build/lib/liblldELF.a ]
+            then
+              # install dependencies
+              sudo apt-get install cmake clang ninja-build
+              # make build faster
+              export CC=clang
+              export CXX=clang++
+              # hack ninja to use less jobs
+              echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
+              chmod +x /go/bin/ninja
+              # build!
+              make ASSERT=1 llvm-build
+            fi
+      - save_cache:
+          key: llvm-build-10-linux-v0-assert
+          paths:
+            llvm-build
+      - run: make ASSERT=1
+      - build-wasi-libc
+      - run:
+          name: "Test TinyGo"
+          command: make ASSERT=1 test
+      - save_cache:
+          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - ~/.cache/tinygo
+            - /go/pkg/mod
+      - run: make gen-device -j4
+      - run: make smoketest TINYGO=build/tinygo
+  build-linux:
+    steps:
+      - checkout
+      - submodules
+      - run:
+          name: "Install apt dependencies"
+          command: |
+            sudo apt-get install \
+                gcc-arm-linux-gnueabihf \
+                binutils-arm-none-eabi \
+                libc6-dev-armel-cross \
+                gcc-aarch64-linux-gnu \
+                libc6-dev-arm64-cross \
+                qemu-system-arm \
+                qemu-user \
+                gcc-avr \
+                avr-libc
+      - install-node
+      - restore_cache:
+          keys:
+            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-v2-{{ checksum "go.mod" }}
+      - llvm-source-linux
+      - restore_cache:
+          keys:
+            - llvm-build-10-linux-v0
+      - run:
+          name: "Build LLVM"
+          command: |
+            if [ ! -f llvm-build/lib/liblldELF.a ]
+            then
+              # install dependencies
+              sudo apt-get install cmake clang ninja-build
+              # make build faster
+              export CC=clang
+              export CXX=clang++
+              # hack ninja to use less jobs
+              echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
+              chmod +x /go/bin/ninja
+              # build!
+              make llvm-build
+            fi
+      - save_cache:
+          key: llvm-build-10-linux-v0
+          paths:
+            llvm-build
+      - build-wasi-libc
+      - run:
+          name: "Test TinyGo"
+          command: make test
+      - run:
+          name: "Build TinyGo release"
+          command: |
+            make release -j3
+            cp -p build/release.tar.gz /tmp/tinygo.linux-amd64.tar.gz
+      - store_artifacts:
+          path: /tmp/tinygo.linux-amd64.tar.gz
+      - save_cache:
+          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - ~/.cache/tinygo
+            - /go/pkg/mod
+      - run:
+          name: "Extract release tarball"
+          command: |
+            mkdir -p ~/lib
+            tar -C ~/lib -xf /tmp/tinygo.linux-amd64.tar.gz
+            ln -s ~/lib/tinygo/bin/tinygo /go/bin/tinygo
+            tinygo version
+      - run: make smoketest
+  build-macos:
+    steps:
+      - checkout
+      - submodules
+      - run:
+          name: "Install dependencies"
+          command: |
+            curl https://dl.google.com/go/go1.14.darwin-amd64.tar.gz -o go1.14.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.14.darwin-amd64.tar.gz
+            ln -s /usr/local/go/bin/go /usr/local/bin/go
+            HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu
+      - restore_cache:
+          keys:
+            - go-cache-macos-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-macos-v2-{{ checksum "go.mod" }}
+      - restore_cache:
+          keys:
+            - llvm-source-10-macos-v0
+      - run:
+          name: "Fetch LLVM source"
+          command: make llvm-source
+      - save_cache:
+          key: llvm-source-10-macos-v0
+          paths:
+            - llvm-project
+      - restore_cache:
+          keys:
+            - llvm-build-10-macos-v0
+      - run:
+          name: "Build LLVM"
+          command: |
+            if [ ! -f llvm-build/lib/liblldELF.a ]
+            then
+              # install dependencies
+              HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake ninja
+              # build!
+              make llvm-build
+            fi
+      - save_cache:
+          key: llvm-build-10-macos-v0
+          paths:
+            llvm-build
+      - restore_cache:
+          keys:
+            - wasi-libc-sysroot-macos-v1
+      - run:
+          name: "Build wasi-libc"
+          command: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-macos-v1
+          paths:
+            - lib/wasi-libc/sysroot
+      - run:
+          name: "Test TinyGo"
+          command: make test
+      - run:
+          name: "Build TinyGo release"
+          command: |
+            make release -j3
+            cp -p build/release.tar.gz /tmp/tinygo.darwin-amd64.tar.gz
+      - store_artifacts:
+          path: /tmp/tinygo.darwin-amd64.tar.gz
+      - run:
+          name: "Extract release tarball"
+          command: |
+            mkdir -p ~/lib
+            tar -C /usr/local/opt -xf /tmp/tinygo.darwin-amd64.tar.gz
+            ln -s /usr/local/opt/tinygo/bin/tinygo /usr/local/bin/tinygo
+            tinygo version
+      - run:
+          name: "Download SiFive GNU toolchain"
+          command: |
+            curl -O https://static.dev.sifive.com/dev-tools/riscv64-unknown-elf-gcc-8.2.0-2019.05.3-x86_64-apple-darwin.tar.gz
+            sudo tar -C /usr/local --strip-components=1 -xf riscv64-unknown-elf-gcc-8.2.0-2019.05.3-x86_64-apple-darwin.tar.gz
+      - run: make smoketest AVR=0
+      - save_cache:
+          key: go-cache-macos-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - ~/.cache/tinygo
+            - /go/pkg/mod
+

 jobs:
-  test-llvm11-go115:
+  test-llvm9-go111:
    docker:
-      - image: circleci/golang:1.15-buster
+      - image: circleci/golang:1.11-buster
    steps:
      - test-linux:
-          llvm: "11"
-  test-llvm12-go116:
+          llvm: "9"
+  test-llvm10-go112:
    docker:
-      - image: circleci/golang:1.16-buster
+      - image: circleci/golang:1.12-buster
    steps:
      - test-linux:
-          llvm: "12"
+          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"
+  assert-test-linux:
+    docker:
+      - image: circleci/golang:1.14-stretch
+    steps:
+      - assert-test-linux
+  build-linux:
+    docker:
+      - image: circleci/golang:1.14-stretch
+    steps:
+      - build-linux
+  build-macos:
+    macos:
+      xcode: "10.1.0"
+    steps:
+      - build-macos
+
+
+

 workflows:
  test-all:
    jobs:
-      - test-llvm11-go115
-      - test-llvm12-go116
+      - test-llvm9-go111
+      - test-llvm10-go112
+      - test-llvm10-go113
+      - test-llvm10-go114
+      - build-linux
+      - build-macos
+      - assert-test-linux
@@ -1,3 +0,0 @@
-build/
-llvm-*/
-
@@ -1,95 +0,0 @@
-name: macOS
-
-on:
-  pull_request:
-  push:
-    branches:
-      - dev
-      - release
-
-jobs:
-  build-macos:
-    name: build-macos
-    runs-on: macos-10.15
-    steps:
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - name: Install Dependencies
-        shell: bash
-        run: |
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu binaryen
-      - name: Install Xtensa toolchain
-        shell: bash
-        run: |
-          curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz
-          sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz
-          sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz
-      - 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-13-macos-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-13-macos-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
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake ninja
-          # build!
-          make llvm-build
-          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 GOTESTFLAGS="-v -short"
-      - name: Build TinyGo release tarball
-        run: make release -j3
-      - name: Make release artifact
-        shell: bash
-        run: cp -p build/release.tar.gz build/tinygo.darwin-amd64.tar.gz 
-      - 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 double-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/tinygo.darwin-amd64.tar.gz
-      - name: Smoke tests
-        shell: bash
-        run: make smoketest TINYGO=$(PWD)/build/tinygo AVR=0
@@ -1,59 +0,0 @@
-# This is the Github action to build and push the tinygo/tinygo-dev Docker image.
-# If you are looking for the tinygo/tinygo "release" Docker image please see
-# https://github.com/tinygo-org/docker
-#
-name: Docker
-on:
-  push:
-    branches: [ dev, fix-docker-llvm-build ]
-
-jobs:
-  push_to_registry:
-    name: build-push-dev
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - name: Check out the repo
-        uses: actions/checkout@v2
-        with:
-          submodules: recursive
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-      - 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 }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-      - name: Trigger Drivers repo build on CircleCI
-        run: |
-          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/drivers/pipeline' \
-            --header 'Content-Type: application/json' \
-            -d '{"branch": "dev"}' \
-            -u "${{ secrets.CIRCLECI_API_TOKEN }}"
@@ -1,241 +0,0 @@
-name: Linux
-
-on:
-  pull_request:
-  push:
-    branches:
-      - dev
-      - release
-
-jobs:
-  build-linux:
-    # Build Linux binaries, ready for release.
-    # This intentionally uses an older Linux image, so that we compile against
-    # an older glibc version and therefore are compatible with a wide range of
-    # Linux distributions.
-    runs-on: ubuntu-18.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Install apt dependencies
-        run: |
-          sudo apt-get install --no-install-recommends \
-              ninja-build
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - name: Cache Go
-        uses: actions/cache@v2
-        with:
-          key: go-cache-linux-v1-${{ hashFiles('go.mod') }}
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-      - name: Cache LLVM source
-        uses: actions/cache@v2
-        id: cache-llvm-source
-        with:
-          key: llvm-source-13-linux-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-13-linux-v1
-          path: llvm-build
-      - name: Build LLVM
-        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
-        run: |
-          # fetch LLVM source
-          rm -rf llvm-project
-          make llvm-source
-          # build!
-          make llvm-build
-          # Remove unnecessary object files (to reduce cache size).
-          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
-      - name: Cache Binaryen
-        uses: actions/cache@v2
-        id: cache-binaryen
-        with:
-          key: binaryen-linux-v1
-          path: build/wasm-opt
-      - name: Build Binaryen
-        if: steps.cache-binaryen.outputs.cache-hit != 'true'
-        run: make binaryen
-      - name: Cache wasi-libc
-        uses: actions/cache@v2
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-linux-asserts-v2
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
-      - name: Install fpm
-        run: |
-          sudo apt-get install ruby ruby-dev
-          sudo gem install --no-document fpm
-      - name: Build TinyGo release
-        run: |
-          make release deb -j3
-          cp -p build/release.tar.gz /tmp/tinygo.linux-amd64.tar.gz
-          cp -p build/release.deb    /tmp/tinygo_amd64.deb
-      - name: Publish release artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: release-double-zipped
-          path: |
-            /tmp/tinygo.linux-amd64.tar.gz
-            /tmp/tinygo_amd64.deb
-  test-linux-build:
-    # Test the binaries built in the build-linux job by running the smoke tests.
-    runs-on: ubuntu-latest
-    needs: build-linux
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - name: Install wasmtime
-        run: |
-          curl https://wasmtime.dev/install.sh -sSf | bash
-          echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
-      - name: Download release artifact
-        uses: actions/download-artifact@v2
-        with:
-          name: release-double-zipped
-      - name: Extract release tarball
-        run: |
-          mkdir -p ~/lib
-          tar -C ~/lib -xf tinygo.linux-amd64.tar.gz
-          ln -s ~/lib/tinygo/bin/tinygo ~/go/bin/tinygo
-      - name: Install apt dependencies
-        run: |
-          sudo apt-get install --no-install-recommends \
-              gcc-avr \
-              avr-libc
-      - name: "Install Xtensa toolchain"
-        run: |
-          curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-      - run: make tinygo-test-wasi-fast
-      - run: make smoketest
-  assert-test-linux:
-    # Run all tests that can run on Linux, with LLVM assertions enabled to catch
-    # potential bugs.
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Install apt dependencies
-        run: |
-          echo "Show cpuinfo; sometimes useful when troubleshooting"
-          cat /proc/cpuinfo
-          sudo apt-get update
-          sudo apt-get install --no-install-recommends \
-              qemu-system-arm \
-              qemu-system-riscv32 \
-              qemu-user \
-              gcc-avr \
-              avr-libc \
-              simavr \
-              ninja-build
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - name: Install Node.js
-        uses: actions/setup-node@v2
-        with:
-          node-version: '12'
-      - name: Install wasmtime
-        run: |
-          curl https://wasmtime.dev/install.sh -sSf | bash
-          echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
-      - name: Cache Go
-        uses: actions/cache@v2
-        with:
-          key: go-cache-linux-asserts-v1-${{ hashFiles('go.mod') }}
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-      - name: Cache LLVM source
-        uses: actions/cache@v2
-        id: cache-llvm-source
-        with:
-          key: llvm-source-13-linux-asserts-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-13-linux-asserts-v1
-          path: llvm-build
-      - name: Build LLVM
-        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
-        run: |
-          # fetch LLVM source
-          rm -rf llvm-project
-          make llvm-source
-          # build!
-          make llvm-build ASSERT=1
-          # Remove unnecessary object files (to reduce cache size).
-          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
-      - name: Cache Binaryen
-        uses: actions/cache@v2
-        id: cache-binaryen
-        with:
-          key: binaryen-linux-asserts-v1
-          path: build/wasm-opt
-      - name: Build Binaryen
-        if: steps.cache-binaryen.outputs.cache-hit != 'true'
-        run: make binaryen
-      - name: Cache wasi-libc
-        uses: actions/cache@v2
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-linux-asserts-v2
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
-      - run: make gen-device -j4
-      - name: Test TinyGo
-        run: make ASSERT=1 test
-      - name: Build TinyGo
-        run: |
-          make ASSERT=1
-          echo "$(pwd)/build" >> $GITHUB_PATH
-      - name: Test stdlib packages
-        run: make tinygo-test
-      - name: Install Xtensa toolchain
-        run: |
-          curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-      - run: make smoketest
-      - run: make wasmtest
@@ -1,97 +0,0 @@
-name: Windows
-
-on:
-  pull_request:
-  push:
-    branches:
-      - dev
-      - release
-
-jobs:
-  build-windows:
-    runs-on: windows-2019
-    steps:
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - uses: MinoruSekine/setup-scoop@v1
-      - name: Install Dependencies
-        shell: bash
-        run: |
-          scoop install ninja binaryen
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Cache Go
-        uses: actions/cache@v2
-        with:
-          key: go-cache-windows-v1-${{ hashFiles('go.mod') }}
-          path: |
-            ~/AppData/Local/go-build
-            ~/go/pkg/mod
-      - name: Cache LLVM source
-        uses: actions/cache@v2
-        id: cache-llvm-source
-        with:
-          key: llvm-source-13-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-13-windows-v1
-          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
-          # 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 GOTESTFLAGS="-v -short"
-      - 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=$(PWD)/build/tinygo AVR=0 XTENSA=0
-      - name: Test stdlib packages
-        run: make tinygo-test
@@ -1,33 +1,16 @@
+build
 docs/_build
 src/device/avr/*.go
 src/device/avr/*.ld
 src/device/avr/*.s
-src/device/esp/*.go
 src/device/nrf/*.go
 src/device/nrf/*.s
-src/device/nxp/*.go
-src/device/nxp/*.s
 src/device/sam/*.go
 src/device/sam/*.s
 src/device/sifive/*.go
 src/device/sifive/*.s
 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
-build/*
-
-# Ignore files generated by smoketest
-test.bin
-test.elf
-test.exe
-test.gba
-test.hex
-test.nro
-test.wasm
-wasm.wasm
@@ -9,7 +9,7 @@
 	url = https://github.com/avr-rust/avr-mcu.git
 [submodule "lib/cmsis-svd"]
 	path = lib/cmsis-svd
-	url = https://github.com/tinygo-org/cmsis-svd
+	url = https://github.com/posborne/cmsis-svd
 [submodule "lib/compiler-rt"]
 	path = lib/compiler-rt
 	url = https://github.com/llvm-mirror/compiler-rt.git
@@ -20,15 +20,3 @@
 [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
-[submodule "lib/binaryen"]
-	path = lib/binaryen
-	url = https://github.com/WebAssembly/binaryen.git
-[submodule "lib/mingw-w64"]
-	path = lib/mingw-w64
-	url = https://github.com/mingw-w64/mingw-w64.git
@@ -10,15 +10,12 @@ This guide describes how to statically link TinyGo against LLVM, libclang and
 lld so that the binary can be easily moved between systems. It also shows how to
 build a release tarball that includes this binary and all necessary extra files.

-**Note**: this documentation describes how to build a statically linked release
-tarball. If you want to help with development of TinyGo itself, you should follow the guide located at https://tinygo.org/docs/guides/build/
-
 ## Dependencies

 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.15+)
+  * Go (1.11+)
  * Standard build tools (gcc/clang)
  * git
  * CMake
@@ -38,6 +35,11 @@ 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
@@ -82,10 +84,6 @@ Now that we have a working static build, it's time to make a release tarball:

    make release

-If you did not clone the repository with the `--recursive` option, you will get errors until you initialize the project submodules:
-
-    git submodule update --init
-
 The release tarball is stored in build/release.tar.gz, and can be extracted with
 the following command (for example in ~/lib):

@@ -1,773 +1,3 @@
-0.22.0
---
-
-* **command line**
-  - add asyncify to scheduler flag help
-  - support -run for tests
-  - remove FreeBSD target support
-  - add LLVM 12 and LLVM 13 support, use LLVM 13 by default
-  - add support for ARM64 MacOS
-  - improve help
-  - check /run/media as well as /media on Linux for non-debian-based distros
-  - `test`: set cmd.Dir even when running emulators
-  - `info`: add JSON output using the `-json` flag
-* **compiler**
-  - `builder`: fix off-by-one in size calculation
-  - `builder`: handle concurrent library header rename
-  - `builder`: use flock to avoid double-compiles
-  - `builder`: use build ID as cache key
-  - `builder`: add -fno-stack-protector to musl build
-  - `builder`: update clang header search path to look in /usr/lib
-  - `builder`: explicitly disable unwind tables for ARM
-  - `cgo`: add support for `C.CString` and related functions
-  - `compiler`: fix ranging over maps with particular map types
-  - `compiler`: add correct debug location to init instructions
-  - `compiler`: fix emission of large object layouts
-  - `compiler`: work around AVR atomics bugs
-  - `compiler`: predeclare runtime.trackPointer
-  - `interp`: work around AVR function pointers in globals
-  - `interp`: run goroutine starts and checks at runtime
-  - `interp`: always run atomic and volatile loads/stores at runtime
-  - `interp`: bump timeout to 180 seconds
-  - `interp`: handle type assertions on nil interfaces
-  - `loader`: elminate goroot cache inconsistency
-  - `loader`: respect $GOROOT when running `go list`
-  - `transform`: allocate the correct amount of bytes in an alloca
-  - `transform`: remove switched func lowering
-* **standard library**
-  - `crypto/rand`: show error if platform has no rng
-  - `device/*`: add `*_Msk` field for each bit field and avoid duplicates
-  - `device/*`: provide Set/Get for each register field described in the SVD files
-  - `internal/task`: swap stack chain when switching goroutines
-  - `internal/task`: remove `-scheduler=coroutines`
-  - `machine`: add `Device` string constant
-  - `net`: add bare Interface implementation
-  - `net`: add net.Buffers
-  - `os`: stub out support for some features
-  - `os`: obey TMPDIR on unix, TMP on Windows, etc
-  - `os`: implement `ReadAt`, `Mkdir`, `Remove`, `Stat`, `Lstat`, `CreateTemp`, `MkdirAll`, `Chdir`, `Chmod`, `Clearenv`, `Unsetenv`, `Setenv`, `MkdirTemp`, `Rename`, `Seek`, `ExpandEnv`, `Symlink`, `Readlink`
-  - `os`: implement `File.Stat`
-  - `os`: fix `IsNotExist` on nonexistent path
-  - `os`: fix opening files on WASI in read-only mode
-  - `os`: work around lack of `syscall.seek` on 386 and arm
-  - `reflect`: make sure indirect pointers are handled correctly
-  - `runtime`: allow comparing interfaces
-  - `runtime`: use LLVM intrinsic to read the stack pointer
-  - `runtime`: strengthen hashmap hash function for structs and arrays
-  - `runtime`: fix float/complex hashing
-  - `runtime`: fix nil map dereference
-  - `runtime`: add realloc implementation to GCs
-  - `runtime`: handle negative sleep times
-  - `runtime`: correct GC scan bounds
-  - `runtime`: remove extalloc GC
-  - `rumtime`: implement `__sync` libcalls as critical sections for most microcontrollers
-  - `runtime`: add stubs for `Func.FileLine` and `Frame.PC`
-  - `sync`: fix concurrent read-lock on write-locked RWMutex
-  - `sync`: add a package doc
-  - `sync`: add tests
-  - `syscall`: add support for `Mmap` and `Mprotect`
-  - `syscall`: fix array size for mmap slice creation
-  - `syscall`: enable `Getwd` in wasi
-  - `testing`: add a stub for `CoverMode`
-  - `testing`: support -bench option to run benchmarks matching the given pattern.
-  - `testing`: support b.SetBytes(); implement sub-benchmarks.
-  - `testing`: replace spaces with underscores in test/benchmark names, as upstream does
-  - `testing`: implement testing.Cleanup
-  - `testing`: allow filtering subbenchmarks with the `-bench` flag
-  - `testing`: implement `-benchtime` flag
-  - `testing`: print duration
-  - `testing`: allow filtering of subtests using `-run`
-* **targets**
-  - `all`: change LLVM features to match vanilla Clang
-  - `avr`: use interrupt-based timer which is much more accurate
-  - `nrf`: fix races in I2C
-  - `samd51`: implement TRNG for randomness
-  - `stm32`: pull-up on I2C lines
-  - `stm32`: fix timeout for i2c comms
-  - `stm32f4`, `stm32f103`: initial implementation for ADC
-  - `stm32f4`, `stm32f7`, `stm32l0x2`, `stm32l4`, `stm32l5`, `stm32wl`: TRNG implementation in crypto/rand
-  - `stm32wl`: add I2C support
-  - `windows`: add support for the `-size=` flag
-  - `wasm`: add support for `tinygo test`
-  - `wasi`, `wasm`: raise default stack size to 16 KiB
-* **boards**
-  - add M5Stack
-  - add lorae5 (stm32wle) support
-  - add Generic Node Sensor Edition
-  - add STM32F469 Discovery
-  - add M5Stamp C3
-  - add Blues Wireless Swan
-  - `bluepill`: add definitions for ADC pins
-  - `stm32f4disco`: add definitions for ADC pins
-  - `stm32l552ze`: use supported stlink interface
-  - `microbit-v2`: add some pin definitions
-
-
-0.21.0
---
-
-* **command line**
-  - drop support for LLVM 10
-  - `build`: drop support for LLVM targets in the -target flag
-  - `build`: fix paths in error messages on Windows
-  - `build`: add -p flag to set parallelism
-  - `lldb`: implement `tinygo lldb` subcommand
-  - `test`: use emulator exit code instead of parsing test output
-  - `test`: pass testing arguments to wasmtime
-* **compiler**
-  - use -opt flag for optimization level in CFlags (-Os, etc)
-  - `builder`: improve accuracy of the -size=full flag
-  - `builder`: hardcode some more frame sizes for __aeabi_* functions
-  - `builder`: add support for -size= flag for WebAssembly
-  - `cgo`: fix line/column reporting in syntax error messages
-  - `cgo`: support function definitions in CGo headers
-  - `cgo`: implement rudimentary C array decaying
-  - `cgo`: add support for stdio in picolibc and wasi-libc
-  - `cgo`: run CGo parser per file, not per CGo fragment
-  - `compiler`: fix unintentionally exported math functions
-  - `compiler`: properly implement div and rem operations
-  - `compiler`: add support for recursive function types
-  - `compiler`: add support for the `go` keyword on interface methods
-  - `compiler`: add minsize attribute for -Oz
-  - `compiler`: add "target-cpu" and "target-features" attributes
-  - `compiler`: fix indices into strings and arrays
-  - `compiler`: fix string compare functions
-  - `interp`: simplify some code to avoid some errors
-  - `interp`: support recursive globals (like linked lists) in globals
-  - `interp`: support constant globals
-  - `interp`: fix reverting of extractvalue/insertvalue with multiple indices
-  - `transform`: work around renamed return type after merging LLVM modules
-* **standard library**
-  - `internal/bytealg`: fix indexing error in Compare()
-  - `machine`: support Pin.Get() function when the pin is configured as output
-  - `net`, `syscall`: Reduce code duplication by switching to internal/itoa.
-  - `os`: don't try to read executable path on baremetal
-  - `os`: implement Getwd
-  - `os`: add File.WriteString and File.WriteAt
-  - `reflect`: fix type.Size() to account for struct padding
-  - `reflect`: don't construct an interface-in-interface value
-  - `reflect`: implement Value.Elem() for interface values
-  - `reflect`: fix Value.Index() in a specific case
-  - `reflect`: add support for DeepEqual
-  - `runtime`: add another set of invalid unicode runes to encodeUTF8()
-  - `runtime`: only initialize os.runtime_args when needed
-  - `runtime`: only use CRLF on baremetal systems for println
-  - `runtime/debug`: stub `debug.SetMaxStack`
-  - `runtime/debug`: stub `debug.Stack`
-  - `testing`: add a stub for t.Parallel()
-  - `testing`: add support for -test.short flag
-  - `testing`: stub B.ReportAllocs()
-  - `testing`: add `testing.Verbose`
-  - `testing`: stub `testing.AllocsPerRun`
-* **targets**
-  - fix gen-device-svd to handle 64-bit values
-  - add CPU and Features property to all targets
-  - match LLVM triple to the one Clang uses
-  - `atsam`: simplify definition of SERCOM UART, I2C and SPI peripherals
-  - `atsam`: move I2S0 to machine file
-  - `esp32`: fix SPI configuration
-  - `esp32c3`: add support for GDB debugging
-  - `esp32c3`: add support for CPU interrupts
-  - `esp32c3`: use tasks scheduler by default
-  - `fe310`: increase CPU frequency from 16MHz to 320MHz
-  - `fe310`: add support for bit banging drivers
-  - `linux`: build static binaries using musl
-  - `linux`: reduce binary size by calling `write` instead of `putchar`
-  - `linux`: add support for GOARM
-  - `riscv`: implement 32-bit atomic operations
-  - `riscv`: align the heap to 16 bytes
-  - `riscv`: switch to tasks-based scheduler
-  - `rp2040`: add CPUFrequency()
-  - `rp2040`: improve I2C baud rate configuration
-  - `rp2040`: add pin interrupt API
-  - `rp2040`: refactor PWM code and fix Period calculation
-  - `stm32f103`: fix SPI
-  - `stm32f103`: make SPI frequency selection more flexible
-  - `qemu`: signal correct exit code to QEMU
-  - `wasi`: run C/C++ constructors at startup
-  - `wasm`: ensure heapptr is aligned
-  - `wasm`: update wasi-libc dependency
-  - `wasm`: wasi: use asyncify
-  - `wasm`: support `-scheduler=none`
-  - `windows`: add support for Windows (amd64 only for now)
-* **boards**
-  - `feather-stm32f405`, `feather-rp2040`: add I2C pin names
-  - `m5stack-core2`: add M5Stack Core2
-  - `nano-33-ble`: SoftDevice s140v7 support
-  - `nano-33-ble`: add constants for more on-board pins
-
-
-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
---
-
-* **command-line**
-  - add initial support for LLVM 11
-  - make lib64 clang include path check more robust
-  - `build`: improve support for GOARCH=386 and add tests
-  - `gdb`: add support for qemu-user targets
-  - `test`: support non-host tests
-  - `test`: add support for -c and -o flags
-  - `test`: implement some benchmark stubs
-* **compiler**
-  - `builder`: improve detection of clang on Fedora
-  - `compiler`: fix floating point comparison bugs
-  - `compiler`: implement negate for complex numbers
-  - `loader`: fix linkname in test binaries
-  - `transform`: add missing return pointer restore for regular coroutine tail
-    calls
-* **standard library**
-  - `machine`: switch default frequency to 4MHz
-  - `machine`: clarify caller's responsibility in `SetInterrupt`
-  - `os`: add `LookupEnv()` stub
-  - `reflect`: implement `Swapper`
-  - `runtime`: fix UTF-8 decoding
-  - `runtime`: gc: use raw stack access whenever possible
-  - `runtime`: use dedicated printfloat32
-  - `runtime`: allow ranging over a nil map
-  - `runtime`: avoid device/nxp dependency in HardFault handler
-  - `testing`: implement dummy Helper method
-  - `testing`: add Run method
-* **targets**
-  - `arm64`: add support for SVCall intrinsic
-  - `atsamd51`: avoid panic when configuring SPI with SDI=NoPin
-  - `avr`: properly support the `.rodata` section
-  - `esp8266`: implement `Pin.Get` function
-  - `nintendoswitch`: fix crash when printing long lines (> 120)
-  - `nintendoswitch`: add env parser and removed unused stuff
-  - `nrf`: add I2C error checking
-  - `nrf`: give more flexibility in picking SPI speeds
-  - `nrf`: fix nrf52832 flash size
-  - `stm32f103`: support wakeups from interrupts
-  - `stm32f405`: add SPI support
-  - `stm32f405`: add I2C support
-  - `wasi`: add support for this target
-  - `wasi`: use 'generic' ABI by default
-  - `wasi`: remove --no-threads flag from wasm-ld
-  - `wasm`: add instanceof support for WebAssembly
-  - `wasm`: use fixed length buffer for putchar
-* **boards**
-  - `d1mini`: add this ESP8266 based board
-  - `esp32`: use board definitions instead of chip names
-  - `qtpy`: add board definition for Adafruit QTPy
-  - `teensy40`: add this board
-
-0.15.0
---
-
-* **command-line**
-  - add cached GOROOT to info subcommand
-  - embed git-hash in tinygo-dev executable
-  - implement tinygo targets to list usable targets
-  - use simpler file copy instead of file renaming to avoid issues on nrf52840 UF2 bootloaders
-  - use ToSlash() to specify program path
-  - support flashing esp32/esp8266 directly from tinygo
-  - when flashing call PortReset only on other than openocd
-* **compiler**
-  - `compileopts`: add support for custom binary formats
-  - `compiler`: improve display of goroutine wrappers
-  - `interp`: don't panic in the Store method
-  - `interp`: replace some panics with error messages
-  - `interp`: show error line in first line of the traceback
-  - `loader`: be more robust when creating the cached GOROOT
-  - `loader`: rewrite/refactor much of the code to use go list directly
-  - `loader`: use ioutil.TempDir to create a temporary directory
-  - `stacksize`: deal with DW_CFA_advance_loc1
-* **standard library**
-  - `runtime`: use waitForEvents when appropriate
-* **wasm**
-  - `wasm`: Remove --no-threads from wasm-ld calls.
-  - `wasm`: update wasi-libc dependency
-* **targets**
-  - `arduino-mega2560`: fix flashing on Windows
-  - `arm`: automatically determine stack sizes
-  - `arm64`: make dynamic loader structs and constants private
-  - `avr`: configure emulator in board files
-  - `cortexm`: fix stack size calculation with interrupts
-  - `flash`: add openocd settings to atsamd21 / atsamd51
-  - `flash`: add openocd settings to nrf5
-  - `microbit`: reelboard: flash using OpenOCD when needed
-  - `nintendoswitch`: Add dynamic loader for runtime loading PIE sections
-  - `nintendoswitch`: fix import cycle on dynamic_arm64.go
-  - `nintendoswitch`: Fix invalid memory read / write in print calls
-  - `nintendoswitch`: simplified assembly code
-  - `nintendoswitch`: support outputting .nro files directly
-* **boards**
-  - `arduino-zero`: Adding support for the Arduino Zero (#1365)
-  - `atsamd2x`: fix BAUD value
-  - `atsamd5x`: fix BAUD value
-  - `bluepill`: Enable stm32's USART2 for the board and map it to UART1 tinygo's device
-  - `device/atsamd51x`: add all remaining bitfield values for PCHCTRLm Mapping
-  - `esp32`: add libgcc ROM functions to linker script
-  - `esp32`: add SPI support
-  - `esp32`: add support for basic GPIO
-  - `esp32`: add support for the Espressif ESP32 chip
-  - `esp32`: configure the I/O matrix for GPIO pins
-  - `esp32`: export machine.PortMask* for bitbanging implementations
-  - `esp8266`: add support for this chip
-  - `machine/atsamd51x,runtime/atsamd51x`: fixes needed for full support for all PWM pins. Also adds some useful constants to clarify peripheral clock usage
-  - `machine/itsybitsy-nrf52840`: add support for Adafruit Itsybitsy nrf52840 (#1243)
-  - `machine/stm32f4`: refactor common code and add new build tag stm32f4 (#1332)
-  - `nrf`: add SoftDevice support for the Circuit Playground Bluefruit
-  - `nrf`: call sd_app_evt_wait when the SoftDevice is enabled
-  - `nrf52840`: add build tags for SoftDevice support
-  - `nrf52840`: use higher priority for USB-CDC code
-  - `runtime/atsamd51x`: use PCHCTRL_GCLK_SERCOMX_SLOW for setting clocks on all SERCOM ports
-  - `stm32f405`: add basic UART handler
-  - `stm32f405`: add STM32F405 machine/runtime, and new board/target feather-stm32f405
-* **build**
-  - `all`: run test binaries in the correct directory
-  - `build`: Fix arch release job
-  - `ci`: run `tinygo test` for known-working packages
-  - `ci`: set git-fetch-depth to 1
-  - `docker`: fix the problem with the wasm build (#1357)
-  - `Makefile`: check whether submodules have been downloaded in some common cases
-* **docs**
-  - add ESP32, ESP8266, and Adafruit Feather STM32F405 to list of supported boards
-
-0.14.1
---
-* **command-line**
-  - support for Go 1.15
-* **compiler**
-  - loader:  work around Windows symlink limitation
-
-0.14.0
---
-* **command-line**
-  - fix `getDefaultPort()` on non-English Windows locales
-  - compileopts: improve error reporting of unsupported flags
-  - fix test subcommand
-  - use auto-retry to locate MSD for UF2 and HEX flashing
-  - fix touchSerialPortAt1200bps on Windows
-  - support package names with backslashes on Windows
-* **compiler**
-  - fix a few crashes due to named types
-  - add support for atomic operations
-  - move the channel blocked list onto the stack
-  - fix -gc=none
-  - fix named string to `[]byte` slice conversion
-  - implement func value and builtin defers
-  - add proper parameter names to runtime.initAll, to fix a panic
-  - builder: fix picolibc include path
-  - builder: use newer version of gohex
-  - builder: try to determine stack size information at compile time
-  - builder: remove -opt=0
-  - interp: fix sync/atomic.Value load/store methods
-  - loader: add Go module support
-  - transform: fix debug information in func lowering pass
-  - transform: do not special-case zero or one implementations of a method call
-  - transform: introduce check for method calls on nil interfaces
-  - transform: gc: track 0-index GEPs to fix miscompilation
-* **cgo**
-  - Add LDFlags support
-* **standard library**
-  - extend stdlib to allow import of more packages
-  - replace master/slave terminology with appropriate alternatives (MOSI->SDO
-    etc)
-  - `internal/bytealg`: reimplement bytealg in pure Go
-  - `internal/task`: fix nil panic in (*internal/task.Stack).Pop
-  - `os`: add Args and stub it with mock data
-  - `os`: implement virtual filesystem support
-  - `reflect`: add Cap and Len support for map and chan
-  - `runtime`: fix return address in scheduler on RISC-V
-  - `runtime`: avoid recursion in printuint64 function
-  - `runtime`: replace ReadRegister with AsmFull inline assembly
-  - `runtime`: fix compilation errors when using gc.extalloc
-  - `runtime`: add cap and len support for chans
-  - `runtime`: refactor time handling (improving accuracy)
-  - `runtime`: make channels work in interrupts
-  - `runtime/interrupt`: add cross-chip disable/restore interrupt support
-  - `sync`: implement `sync.Cond`
-  - `sync`: add WaitGroup
-* **targets**
-  - `arm`: allow nesting in DisableInterrupts and EnableInterrupts
-  - `arm`: make FPU configuraton consistent
-  - `arm`: do not mask fault handlers in critical sections
-  - `atmega2560`: fix pin mapping for pins D2, D5 and the L port
-  - `atsamd`: return an error when an incorrect PWM pin is used
-  - `atsamd`: add support for pin change interrupts
-  - `atsamd`: add DAC support
-  - `atsamd21`: add more ADC pins
-  - `atsamd51`: fix ROM / RAM size on atsamd51j20
-  - `atsamd51`: add more pins
-  - `atsamd51`: add more ADC pins
-  - `atsamd51`: add pin change interrupt settings
-  - `atsamd51`: extend pinPadMapping
-  - `arduino-nano33`: use (U)SB flag to ensure that device can be found when
-     not on default port
-  - `arduino-nano33`: remove (d)ebug flag to reduce console noise when flashing
-  - `avr`: use standard pin numbering
-  - `avr`: unify GPIO pin/port code
-  - `avr`: add support for PinInputPullup
-  - `avr`: work around codegen bug in LLVM 10
-  - `avr`: fix target triple
-  - `fe310`: remove extra println left in by mistake
-  - `feather-nrf52840`: add support for the Feather nRF52840
-  - `maixbit`: add board definition and dummy runtime
-  - `nintendoswitch`: Add experimental Nintendo Switch support without CRT
-  - `nrf`: expose the RAM base address
-  - `nrf`: add support for pin change interrupts
-  - `nrf`: add microbit-s110v8 target
-  - `nrf`: fix bug in SPI.Tx
-  - `nrf`: support debugging the PCA10056
-  - `pygamer`: add Adafruit PyGamer suport
-  - `riscv`: fix interrupt configuration bug
-  - `riscv`: disable linker relaxations during gp init
-  - `stm32f4disco`: add new target with ST-Link v2.1 debugger
-  - `teensy36`: add Teensy 3.6 support
-  - `wasm`: fix event handling
-  - `wasm`: add --no-demangle linker option
-  - `wioterminal`: add support for the Seeed Wio Terminal
-  - `xiao`: add support for the Seeed XIAO
-
 0.13.1
 ---
 * **standard library**
@@ -1 +1,52 @@
-Please take a look at our [Contributing](https://tinygo.org/docs/guides/contributing/) page on our web site for details. Thank you.
+# How to contribute
+
+Thank you for your interest in improving TinyGo.
+
+We would like your help to make this project better, so we appreciate any contributions. See if one of the following descriptions matches your situation:
+
+### New to TinyGo
+
+We'd love to get your feedback on getting started with TinyGo. Run into any difficulty, confusion, or anything else? You are not alone. We want to know about your experience, so we can help the next people. Please open a Github issue with your questions, or you can also get in touch directly with us on our Slack channel at [https://gophers.slack.com/messages/CDJD3SUP6](https://gophers.slack.com/messages/CDJD3SUP6).
+
+### Something in TinyGo is not working as you expect
+
+Please open a Github issue with your problem, and we will be happy to assist.
+
+### Something in Go that you want/need does not appear to be in TinyGo
+
+We probably have not implemented it yet. Please take a look at our [Roadmap](https://github.com/tinygo-org/tinygo/wiki/Roadmap). Your pull request adding the functionality to TinyGo would be greatly appreciated.
+
+Please open a Github issue. We want to help, and also make sure that there is no duplications of efforts. Sometimes what you need is already being worked on by someone else.
+
+A long tail of small (and large) language features haven't been implemented yet. In almost all cases, the compiler will show a `todo:` error from `compiler/compiler.go` when you try to use it. You can try implementing it, or open a bug report with a small code sample that fails to compile.
+
+### Some specific hardware you want to use does not appear to be in TinyGo
+
+As above, we probably have not implemented it yet. Your contribution adding the hardware support to TinyGo would be greatly appreciated.
+
+Please start by opening a Github issue. We want to help you to help us to help you.
+
+Lots of targets/boards are still unsupported. Adding an architecture often requires a few compiler changes, but if the architecture is supported you can try implementing support for a new chip or board in `src/runtime`. For details, see [this wiki entry on adding archs/chips/boards](https://github.com/tinygo-org/tinygo/wiki/Adding-a-new-board).
+
+Microcontrollers have lots of peripherals (I2C, SPI, ADC, etc.) and many don't have an implementation yet in the `machine` package. Adding support for new peripherals is very useful.
+
+## How to use our Github repository
+
+The `master` branch of this repo will always have the latest released version of TinyGo. All of the active development work for the next release will take place in the `dev` branch. TinyGo will use semantic versioning and will create a tag/release for each release.
+
+Here is how to contribute back some code or documentation:
+
+- Fork repo
+- Create a feature branch off of the `dev` branch
+- Make some useful change
+- Make sure the tests still pass
+- Submit a pull request against the `dev` branch.
+- Be kind
+
+## How to run tests
+
+To run the tests:
+
+```
+make test
+```
@@ -15,4 +15,4 @@ Ayke van Laethem <aykevanlaethem@gmail.com>
 Daniel Esteban <conejo@conejo.me>
 Loon, LLC.
 Ron Evans <ron@hybridgroup.com>
-Nia Weiss <niaow1234@gmail.com>
+Jaden Weiss <jaden@jadendw.dev>
@@ -1,50 +1,79 @@
-# tinygo-llvm stage obtains the llvm source for TinyGo
-FROM golang:1.17 AS tinygo-llvm
+# TinyGo base stage installs Go 1.14, LLVM 10 and the TinyGo compiler itself.
+FROM golang:1.14 AS tinygo-base

-RUN apt-get update && \
-    apt-get install -y apt-utils make cmake clang-11 binutils-avr gcc-avr avr-libc ninja-build
-
-COPY ./Makefile /tinygo/Makefile
-
-RUN cd /tinygo/ && \
-    make llvm-source
-
-# tinygo-llvm-build stage build the custom llvm with xtensa support
-FROM tinygo-llvm AS tinygo-llvm-build
-
-RUN cd /tinygo/ && \
-    make llvm-build
-
-# tinygo-xtensa stage installs tools needed for ESP32
-FROM tinygo-llvm-build AS tinygo-xtensa
-
-ARG xtensa_version="1.22.0-80-g6c4433a-5.2.0"
-RUN cd /tmp/ && \
-    wget -q https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-${xtensa_version}.tar.gz && \
-    tar xzf xtensa-esp32-elf-linux64-${xtensa_version}.tar.gz && \
-    cp ./xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/ && \
-    rm -rf /tmp/xtensa*
-
-# tinygo-compiler stage builds the compiler itself
-FROM tinygo-xtensa AS tinygo-compiler
+RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main" >> /etc/apt/sources.list && \
+    apt-get update && \
+    apt-get install -y llvm-10-dev libclang-10-dev git

 COPY . /tinygo

-# update submodules
+# remove submodules directories and re-init them to fix any hard-coded paths
+# after copying the tinygo directory in the previous step.
 RUN cd /tinygo/ && \
-    rm -rf ./lib/*/ && \
+    rm -rf ./lib/* && \
    git submodule sync && \
    git submodule update --init --recursive --force

-RUN cd /tinygo/ && \
-    make
-
-# tinygo-tools stage installs the needed dependencies to compile TinyGo programs for all platforms.
-FROM tinygo-compiler AS tinygo-tools
+COPY ./lib/picolibc-include/* /tinygo/lib/picolibc-include/

 RUN cd /tinygo/ && \
-    make wasi-libc binaryen && \
-    make gen-device -j4 && \
-    cp build/* $GOPATH/bin/
+    go install /tinygo/
+
+# tinygo-wasm stage installs the needed dependencies to compile TinyGo programs for WASM.
+FROM tinygo-base AS tinygo-wasm
+
+COPY --from=tinygo-base /go/bin/tinygo /go/bin/tinygo
+COPY --from=tinygo-base /tinygo/src /tinygo/src
+COPY --from=tinygo-base /tinygo/targets /tinygo/targets
+
+RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main" >> /etc/apt/sources.list && \
+    apt-get update && \
+    apt-get install -y libllvm10 lld-10
+
+# tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
+FROM tinygo-base AS tinygo-avr
+
+COPY --from=tinygo-base /go/bin/tinygo /go/bin/tinygo
+COPY --from=tinygo-base /tinygo/src /tinygo/src
+COPY --from=tinygo-base /tinygo/targets /tinygo/targets
+COPY --from=tinygo-base /tinygo/Makefile /tinygo/
+COPY --from=tinygo-base /tinygo/tools /tinygo/tools
+COPY --from=tinygo-base /tinygo/lib /tinygo/lib
+
+RUN cd /tinygo/ && \
+    apt-get update && \
+    apt-get install -y apt-utils make binutils-avr gcc-avr avr-libc && \
+    make gen-device-avr && \
+    apt-get autoremove -y && \
+    apt-get clean
+
+# tinygo-arm stage installs the needed dependencies to compile TinyGo programs for ARM microcontrollers.
+FROM tinygo-base AS tinygo-arm
+
+COPY --from=tinygo-base /go/bin/tinygo /go/bin/tinygo
+COPY --from=tinygo-base /tinygo/src /tinygo/src
+COPY --from=tinygo-base /tinygo/targets /tinygo/targets
+COPY --from=tinygo-base /tinygo/Makefile /tinygo/
+COPY --from=tinygo-base /tinygo/tools /tinygo/tools
+COPY --from=tinygo-base /tinygo/lib /tinygo/lib
+
+RUN cd /tinygo/ && \
+    apt-get update && \
+    apt-get install -y apt-utils make clang-10 && \
+    make gen-device-nrf && make gen-device-stm32
+
+# tinygo-all stage installs the needed dependencies to compile TinyGo programs for all platforms.
+FROM tinygo-wasm AS tinygo-all
+
+COPY --from=tinygo-base /tinygo/Makefile /tinygo/
+COPY --from=tinygo-base /tinygo/tools /tinygo/tools
+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 && \
+    make gen-device

 CMD ["tinygo"]
@@ -1,7 +1,7 @@
-Copyright (c) 2018-2022 The TinyGo Authors. All rights reserved.
+Copyright (c) 2018-2020 TinyGo Authors. All rights reserved.

 TinyGo includes portions of the Go standard library.
-Copyright (c) 2009-2022 The Go Authors. All rights reserved.
+Copyright (c) 2009-2020 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.
@@ -9,34 +9,35 @@ CLANG_SRC ?= $(LLVM_PROJECTDIR)/clang
 LLD_SRC ?= $(LLVM_PROJECTDIR)/lld

 # Try to autodetect LLVM build tools.
-# Versions are listed here in descending priority order.
-LLVM_VERSIONS = 13 12 11
-errifempty = $(if $(1),$(1),$(error $(2)))
-detect = $(shell which $(call errifempty,$(firstword $(foreach p,$(2),$(shell command -v $(p) 2> /dev/null && echo $(p)))),failed to locate $(1) at any of: $(2)))
-toolSearchPathsVersion = $(1)-$(2)
-ifeq ($(shell uname -s),Darwin)
-	# Also explicitly search Brew's copy, which is not in PATH by default.
-	BREW_PREFIX := $(shell brew --prefix)
-	toolSearchPathsVersion += $(BREW_PREFIX)/opt/llvm@$(2)/bin/$(1)-$(2) $(BREW_PREFIX)/opt/llvm@$(2)/bin/$(1)
+ifneq (, $(shell command -v llvm-build/bin/clang 2> /dev/null))
+    CLANG ?= $(abspath llvm-build/bin/clang)
+else
+    CLANG ?= clang-10
+endif
+ifneq (, $(shell command -v llvm-build/bin/llvm-ar 2> /dev/null))
+    LLVM_AR ?= $(abspath llvm-build/bin/llvm-ar)
+else ifneq (, $(shell command -v llvm-ar-10 2> /dev/null))
+    LLVM_AR ?= llvm-ar-10
+else
+    LLVM_AR ?= llvm-ar
+endif
+ifneq (, $(shell command -v llvm-build/bin/llvm-nm 2> /dev/null))
+    LLVM_NM ?= $(abspath llvm-build/bin/llvm-nm)
+else ifneq (, $(shell command -v llvm-nm-10 2> /dev/null))
+    LLVM_NM ?= llvm-nm-10
+else
+    LLVM_NM ?= llvm-nm
 endif
-# First search for a custom built copy, then move on to explicitly version-tagged binaries, then just see if the tool is in path with its normal name.
-findLLVMTool = $(call detect,$(1),$(abspath llvm-build/bin/$(1)) $(foreach ver,$(LLVM_VERSIONS),$(call toolSearchPathsVersion,$(1),$(ver))) $(1))
-CLANG ?= $(call findLLVMTool,clang)
-LLVM_AR ?= $(call findLLVMTool,llvm-ar)
-LLVM_NM ?= $(call findLLVMTool,llvm-nm)

 # Go binary and GOROOT to select
 GO ?= go
 export GOROOT = $(shell $(GO) env GOROOT)

-# Flags to pass to go test.
-GOTESTFLAGS ?= -v
-
 # md5sum binary
 MD5SUM = md5sum

 # tinygo binary for tests
-TINYGO ?= $(call detect,tinygo,tinygo $(CURDIR)/build/tinygo)
+TINYGO ?= tinygo

 # Use CCACHE for LLVM if possible
 ifneq (, $(shell command -v ccache 2> /dev/null))
@@ -50,9 +51,9 @@ 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 gen-device-rp
+.PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-avr

-LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines coverage debuginfodwarf debuginfopdb executionengine frontendopenmp instrumentation interpreter ipo irreader libdriver linker lto mc mcjit objcarcopts option profiledata scalaropts support target windowsmanifest
+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

 ifeq ($(OS),Windows_NT)
    EXE = .exe
@@ -62,74 +63,64 @@ ifeq ($(OS),Windows_NT)
    # LLVM compiled using MinGW on Windows appears to have problems with threads.
    # Without this flag, linking results in errors like these:
    #     libLLVMSupport.a(Threading.cpp.obj):Threading.cpp:(.text+0x55): undefined reference to `std::thread::hardware_concurrency()'
-    LLVM_OPTION += -DLLVM_ENABLE_THREADS=OFF -DLLVM_ENABLE_PIC=OFF
+    LLVM_OPTION += -DLLVM_ENABLE_THREADS=OFF

-    CGO_CPPFLAGS += -DCINDEX_NO_EXPORTS
    CGO_LDFLAGS += -static -static-libgcc -static-libstdc++
    CGO_LDFLAGS_EXTRA += -lversion

-    USE_SYSTEM_BINARYEN ?= 1
+    # Build libclang manually because the CMake-based build system on Windows
+    # doesn't allow building libclang as a static library.
+    LIBCLANG_PATH = $(abspath build/libclang-custom.a)
+    LIBCLANG_FILES = $(abspath $(wildcard $(LLVM_BUILDDIR)/tools/clang/tools/libclang/CMakeFiles/libclang.dir/*.cpp.obj))
+
+    # Add the libclang dependency to the tinygo binary target.
+tinygo: $(LIBCLANG_PATH)
+test: $(LIBCLANG_PATH)
+    # Build libclang.
+$(LIBCLANG_PATH): $(LIBCLANG_FILES)
+	@mkdir -p build
+	ar rcs $(LIBCLANG_PATH) $^

 else ifeq ($(shell uname -s),Darwin)
    MD5SUM = md5
-
-    USE_SYSTEM_BINARYEN ?= 1
-
+    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
 else ifeq ($(shell uname -s),FreeBSD)
    MD5SUM = md5
+    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
    START_GROUP = -Wl,--start-group
    END_GROUP = -Wl,--end-group
 else
+    LIBCLANG_PATH = $(abspath $(LLVM_BUILDDIR))/lib/libclang.a
    START_GROUP = -Wl,--start-group
    END_GROUP = -Wl,--end-group
 endif

-# 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++
+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 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)
+LLD_LIBS = $(START_GROUP) -llldCOFF -llldCommon -llldCore -llldDriver -llldELF -llldMachO -llldMinGW -llldReaderWriter -llldWasm -llldYAML $(END_GROUP)

-# Other libraries that are needed to link TinyGo.
-EXTRA_LIB_NAMES = LLVMInterpreter
-
-# All libraries to be built and linked with the tinygo binary (lib/lib*.a).
-LIB_NAMES = clang $(CLANG_LIB_NAMES) $(LLD_LIB_NAMES) $(EXTRA_LIB_NAMES)
-
-# 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,$(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_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+=-L$(abspath $(LLVM_BUILDDIR)/lib) -lclang $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS)) -lstdc++ $(CGO_LDFLAGS_EXTRA)
+    CGO_LDFLAGS+=$(LIBCLANG_PATH) -std=c++14 -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 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_PATHS = ./*.go builder cgo compiler compiler/testdata interp loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/internal/reflectlite transform
 fmt:
 	@gofmt -l -w $(FMT_PATHS)
 fmt-check:
 	@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-kendryte gen-device-nxp gen-device-rp
-ifneq ($(STM32), 0)
-gen-device: gen-device-stm32
-endif
+gen-device: gen-device-avr gen-device-nrf gen-device-sam gen-device-sifive gen-device-stm32

 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
 	$(GO) build -o ./build/gen-device-avr ./tools/gen-device-avr/
 	./build/gen-device-avr lib/avr/packs/atmega src/device/avr/
 	./build/gen-device-avr lib/avr/packs/tiny src/device/avr/
@@ -138,19 +129,10 @@ gen-device-avr:
 build/gen-device-svd: ./tools/gen-device-svd/*.go
 	$(GO) build -o $@ ./tools/gen-device-svd/

-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
 	./build/gen-device-svd -source=https://github.com/NordicSemiconductor/nrfx/tree/master/mdk lib/nrfx/mdk/ src/device/nrf/
 	GO111MODULE=off $(GO) fmt ./src/device/nrf

-gen-device-nxp: build/gen-device-svd
-	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/NXP lib/cmsis-svd/data/NXP/ src/device/nxp/
-	GO111MODULE=off $(GO) fmt ./src/device/nxp
-
 gen-device-sam: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Atmel lib/cmsis-svd/data/Atmel/ src/device/sam/
 	GO111MODULE=off $(GO) fmt ./src/device/sam
@@ -159,157 +141,48 @@ gen-device-sifive: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/SiFive-Community -interrupts=software lib/cmsis-svd/data/SiFive-Community/ src/device/sifive/
 	GO111MODULE=off $(GO) fmt ./src/device/sifive

-gen-device-kendryte: build/gen-device-svd
-	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Kendryte-Community -interrupts=software lib/cmsis-svd/data/Kendryte-Community/ src/device/kendryte/
-	GO111MODULE=off $(GO) fmt ./src/device/kendryte
-
 gen-device-stm32: build/gen-device-svd
-	./build/gen-device-svd -source=https://github.com/tinygo-org/stm32-svd lib/stm32-svd/svd src/device/stm32/
+	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/STMicro lib/cmsis-svd/data/STMicro/ 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)/llvm:
-	git clone -b xtensa_release_13.0.0 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
-llvm-source: $(LLVM_PROJECTDIR)/llvm
+$(LLVM_PROJECTDIR)/README.md:
+	git clone -b release/10.x https://github.com/llvm/llvm-project $(LLVM_PROJECTDIR)
+llvm-source: $(LLVM_PROJECTDIR)/README.md

 # 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_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)
+	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" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF $(LLVM_OPTION)

 # Build LLVM.
 $(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
-	cd $(LLVM_BUILDDIR) && ninja $(NINJA_BUILD_TARGETS)
+	cd $(LLVM_BUILDDIR); ninja

-ifneq ($(USE_SYSTEM_BINARYEN),1)
-# Build Binaryen
-.PHONY: binaryen
-binaryen: build/wasm-opt$(EXE)
-build/wasm-opt$(EXE):
-	mkdir -p build
-	cd lib/binaryen && cmake -G Ninja . -DBUILD_STATIC_LIB=ON $(BINARYEN_OPTION) && ninja bin/wasm-opt$(EXE)
-	cp lib/binaryen/bin/wasm-opt$(EXE) build/wasm-opt$(EXE)
-endif

 # Build wasi-libc sysroot
 .PHONY: wasi-libc
 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_CFLAGS="-O2 -g -DNDEBUG" WASM_CC=$(CLANG) WASM_AR=$(LLVM_AR) WASM_NM=$(LLVM_NM)
+	cd lib/wasi-libc && make -j4 WASM_CC=$(CLANG) WASM_AR=$(LLVM_AR) WASM_NM=$(LLVM_NM)


 # Build the Go compiler.
 tinygo:
 	@if [ ! -f "$(LLVM_BUILDDIR)/bin/llvm-config" ]; then echo "Fetch and build LLVM first by running:"; echo "  make llvm-source"; echo "  make $(LLVM_BUILDDIR)"; exit 1; fi
-	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`" .
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -o build/tinygo$(EXE) -tags byollvm .

 test: wasi-libc
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=20m -buildmode exe -tags byollvm ./builder ./cgo ./compileopts ./compiler ./interp ./transform .
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test -v -tags byollvm ./cgo ./compileopts ./compiler ./interp ./transform .

-# Tests that take over a minute in wasi
-TEST_PACKAGES_SLOW = \
-	compress/bzip2 \
-	compress/flate \
-	crypto/dsa \
-	index/suffixarray \
-
-TEST_PACKAGES_BASE = \
-	compress/zlib \
-	container/heap \
-	container/list \
-	container/ring \
-	crypto/des \
-	crypto/elliptic/internal/fiat \
-	crypto/internal/subtle \
-	crypto/md5 \
-	crypto/rc4 \
-	crypto/sha1 \
-	crypto/sha256 \
-	crypto/sha512 \
-	debug/macho \
-	encoding \
-	encoding/ascii85 \
-	encoding/base32 \
-	encoding/csv \
-	encoding/hex \
-	go/scanner \
-	hash \
-	hash/adler32 \
-	hash/crc64 \
-	hash/fnv \
-	html \
-	internal/itoa \
-	internal/profile \
-	math \
-	math/cmplx \
-	net/http/internal/ascii \
-	net/mail \
-	os \
-	path \
-	reflect \
-	sync \
-	testing \
-	testing/iotest \
-	text/scanner \
-	unicode \
-	unicode/utf16 \
-	unicode/utf8 \
-
-# Standard library packages that pass tests natively
-TEST_PACKAGES := \
-	$(TEST_PACKAGES_BASE)
-
-# archive/zip requires ReadAt, which is not yet supported on windows
-ifneq ($(OS),Windows_NT)
-TEST_PACKAGES := \
-	$(TEST_PACKAGES) \
-	archive/zip
-endif
-
-# Standard library packages that pass tests on wasi
-TEST_PACKAGES_WASI = \
-	$(TEST_PACKAGES_BASE)
-
-# Test known-working standard library packages.
-# TODO: parallelize, and only show failing tests (no implied -v flag).
-.PHONY: tinygo-test
 tinygo-test:
-	$(TINYGO) test $(TEST_PACKAGES) $(TEST_PACKAGES_SLOW)
-tinygo-test-fast:
-	$(TINYGO) test $(TEST_PACKAGES)
-tinygo-bench:
-	$(TINYGO) test -bench . $(TEST_PACKAGES) $(TEST_PACKAGES_SLOW)
-tinygo-bench-fast:
-	$(TINYGO) test -bench . $(TEST_PACKAGES)
-tinygo-test-wasi:
-	$(TINYGO) test -target wasi $(TEST_PACKAGES_WASI) $(TEST_PACKAGES_SLOW)
-tinygo-test-wasi-fast:
-	$(TINYGO) test -target wasi $(TEST_PACKAGES_WASI)
-tinygo-bench-wasi:
-	$(TINYGO) test -target wasi -bench . $(TEST_PACKAGES_WASI) $(TEST_PACKAGES_SLOW)
-tinygo-bench-wasi-fast:
-	$(TINYGO) test -target wasi -bench . $(TEST_PACKAGES_WASI)
-
-# Test external packages in a large corpus.
-test-corpus:
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus . -corpus=testdata/corpus.yaml
-test-corpus-fast:
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus -short . -corpus=testdata/corpus.yaml
-test-corpus-wasi: wasi-libc
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus . -corpus=testdata/corpus.yaml -target=wasi
-
+	cd tests/tinygotest && tinygo test

 .PHONY: smoketest
 smoketest:
 	$(TINYGO) version
-	# regression test for #2563
-	cd tests/os/smoke && $(TINYGO) test -c -target=pybadge && rm smoke.test
-	# test all examples (except pwm)
+	# test all examples
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/adc
@@ -328,11 +201,9 @@ 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
+	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/pwm
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/serial
 	@$(MD5SUM) test.hex
@@ -341,35 +212,31 @@ smoketest:
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/test
 	@$(MD5SUM) test.hex
 	# test simulated boards on play.tinygo.org
-ifneq ($(WASM), 0)
-	$(TINYGO) build -size short -o test.wasm -tags=arduino              examples/blinky1
+	$(TINYGO) build             -o test.wasm -tags=arduino              examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=hifive1b             examples/blinky1
+	$(TINYGO) build             -o test.wasm -tags=hifive1-qemu         examples/serial
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=reelboard            examples/blinky1
+	$(TINYGO) build             -o test.wasm -tags=hifive1b             examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=pca10040             examples/blinky2
+	$(TINYGO) build             -o test.wasm -tags=reelboard            examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=pca10056             examples/blinky2
+	$(TINYGO) build             -o test.wasm -tags=pca10040             examples/blinky2
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=circuitplay_express  examples/blinky1
+	$(TINYGO) build             -o test.wasm -tags=pca10056             examples/blinky2
+	@$(MD5SUM) test.wasm
+	$(TINYGO) build             -o test.wasm -tags=circuitplay_express  examples/blinky1
 	@$(MD5SUM) test.wasm
-endif
 	# test all targets/boards
 	$(TINYGO) build -size short -o test.hex -target=pca10040-s132v6     examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=microbit            examples/echo
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=microbit-s110v8     examples/echo
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=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
@@ -378,10 +245,6 @@ endif
 	@$(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
@@ -390,16 +253,18 @@ endif
 	@$(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=circuitplay-bluefruit examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/i2s
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=clue-alpha          examples/blinky1
+	$(TINYGO) build -size short -o test.hex -target=clue_alpha          examples/blinky1
 	@$(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
@@ -416,6 +281,8 @@ endif
 	@$(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
@@ -424,104 +291,13 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=reelboard-s140v7    examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=wioterminal         examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pygamer             examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=xiao                examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/dac
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=pyportal            examples/dac
-	@$(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/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=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
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m4        examples/pwm
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=feather-m4          examples/pwm
-	@$(MD5SUM) test.hex
-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=nucleo-wl55jc       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
-	$(TINYGO) build -size short -o test.hex -target=stm32f469disco      examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=lorae5              examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=swan                examples/blinky1
-	@$(MD5SUM) test.hex
-endif
 ifneq ($(AVR), 0)
 	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino             examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino             examples/pwm
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino -scheduler=tasks  examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino-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
@@ -529,131 +305,44 @@ ifneq ($(AVR), 0)
 	$(TINYGO) build -size short -o test.hex -target=digispark -gc=leaking examples/blinky1
 	@$(MD5SUM) test.hex
 endif
-ifneq ($(XTENSA), 0)
-	$(TINYGO) build -size short -o test.bin -target=esp32-mini32      	examples/blinky1
-	@$(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
-	$(TINYGO) build -size short -o test.bin -target m5stack             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.bin -target=m5stamp-c3          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
-ifneq ($(WASM), 0)
-	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/export
-	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/main
-endif
-	# 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
-	GOOS=windows GOARCH=amd64 $(TINYGO) build -size short -o test.exe   ./testdata/cgo
-ifneq ($(OS),Windows_NT)
-	# TODO: this does not yet work on Windows. Somehow, unused functions are
-	# not garbage collected.
-	$(TINYGO) build -o test.elf -gc=leaking -scheduler=none examples/serial
-endif
+	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/export
+	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/main

-
-wasmtest:
-	$(GO) test ./tests/wasm
-
-build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN)),,binaryen)
+release: tinygo gen-device wasi-libc
 	@mkdir -p build/release/tinygo/bin
 	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
 	@mkdir -p build/release/tinygo/lib/compiler-rt/lib
-	@mkdir -p build/release/tinygo/lib/mingw-w64/mingw-w64-crt/lib-common
-	@mkdir -p build/release/tinygo/lib/mingw-w64/mingw-w64-headers/defaults
-	@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/thumbv6m-unknown-unknown-eabi-cortex-m0
-	@mkdir -p build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus
-	@mkdir -p build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4
+	@mkdir -p build/release/tinygo/pkg/armv6m-none-eabi
+	@mkdir -p build/release/tinygo/pkg/armv7m-none-eabi
+	@mkdir -p build/release/tinygo/pkg/armv7em-none-eabi
 	@echo copying source files
 	@cp -p  build/tinygo$(EXE)           build/release/tinygo/bin
-ifneq ($(USE_SYSTEM_BINARYEN),1)
-	@cp -p  build/wasm-opt$(EXE)         build/release/tinygo/bin
-endif
 	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
 	@cp -rp lib/CMSIS/CMSIS/Include      build/release/tinygo/lib/CMSIS/CMSIS
 	@cp -rp lib/CMSIS/README.md          build/release/tinygo/lib/CMSIS
 	@cp -rp lib/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt/lib
 	@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/mingw-w64/mingw-w64-crt/def-include                 build/release/tinygo/lib/mingw-w64/mingw-w64-crt
-	@cp -rp lib/mingw-w64/mingw-w64-crt/lib-common/api-ms-win-crt-* build/release/tinygo/lib/mingw-w64/mingw-w64-crt/lib-common
-	@cp -rp lib/mingw-w64/mingw-w64-crt/lib-common/kernel32.def.in  build/release/tinygo/lib/mingw-w64/mingw-w64-crt/lib-common
-	@cp -rp lib/mingw-w64/mingw-w64-headers/crt/                    build/release/tinygo/lib/mingw-w64/mingw-w64-headers
-	@cp -rp lib/mingw-w64/mingw-w64-headers/defaults/include        build/release/tinygo/lib/mingw-w64/mingw-w64-headers/defaults
 	@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/newlib/libm/common      build/release/tinygo/lib/picolibc/newlib/libm
-	@cp -rp lib/picolibc-stdio.c         build/release/tinygo/lib
+	@cp -rp lib/picolibc-include         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=cortex-m0     -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0/compiler-rt     compiler-rt
-	./build/tinygo build-library -target=cortex-m0plus -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus/compiler-rt compiler-rt
-	./build/tinygo build-library -target=cortex-m4     -o build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4/compiler-rt    compiler-rt
-	./build/tinygo build-library -target=cortex-m0     -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0/picolibc     picolibc
-	./build/tinygo build-library -target=cortex-m0plus -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus/picolibc picolibc
-	./build/tinygo build-library -target=cortex-m4     -o build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4/picolibc    picolibc
-
-release: build/release
+	./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
 	tar -czf build/release.tar.gz -C build/release tinygo
-
-deb: build/release
-	@mkdir -p build/release-deb/usr/local/bin
-	@mkdir -p build/release-deb/usr/local/lib
-	cp -ar build/release/tinygo build/release-deb/usr/local/lib/tinygo
-	ln -sf ../lib/tinygo/bin/tinygo build/release-deb/usr/local/bin/tinygo
-	fpm -f -s dir -t deb -n tinygo -v $(shell grep "const Version = " goenv/version.go | awk '{print $$NF}') -m '@tinygo-org' --description='TinyGo is a Go compiler for small places.' --license='BSD 3-Clause' --url=https://tinygo.org/ --deb-changelog CHANGELOG.md -p build/release.deb -C ./build/release-deb
@@ -1,6 +1,6 @@
 # TinyGo - Go compiler for small places

-[![Linux](https://github.com/tinygo-org/tinygo/actions/workflows/linux.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/linux.yml) [![macOS](https://github.com/tinygo-org/tinygo/actions/workflows/build-macos.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/build-macos.yml) [![Windows](https://github.com/tinygo-org/tinygo/actions/workflows/windows.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/windows.yml) [![Docker](https://github.com/tinygo-org/tinygo/actions/workflows/docker.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/docker.yml) [![CircleCI](https://circleci.com/gh/tinygo-org/tinygo/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/tinygo/tree/dev)
+[![CircleCI](https://circleci.com/gh/tinygo-org/tinygo/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/tinygo/tree/dev) [![Build Status](https://dev.azure.com/tinygo/tinygo/_apis/build/status/tinygo-CI?branchName=dev)](https://dev.azure.com/tinygo/tinygo/_build/latest?definitionId=1&branchName=dev)

 TinyGo is a Go compiler intended for use in small places such as microcontrollers, WebAssembly (Wasm), and command-line tools.

@@ -43,88 +43,40 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for

 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.

-The following 80 microcontroller boards are currently supported:
+The following 32 microcontroller boards are currently supported:

 * [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333)
 * [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)
-* [Adafruit CLUE](https://www.adafruit.com/product/4500)
+* [Adafruit CLUE Alpha](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 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 Nano33 IoT](https://store.arduino.cc/nano-33-iot)
 * [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/)
-* [blues wireless Swan](https://blues.io/products/swan/)
 * [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 - Core board](https://www.espressif.com/en/products/socs/esp32)
-* [ESP32 - mini32](https://www.espressif.com/en/products/socs/esp32)
-* [ESP8266 - d1mini](https://www.espressif.com/en/products/socs/esp8266)
-* [ESP8266 - NodeMCU](https://www.espressif.com/en/products/socs/esp8266)
 * [Game Boy Advance](https://en.wikipedia.org/wiki/Game_Boy_Advance)
-* [M5Stack](https://docs.m5stack.com/en/core/basic)
-* [M5Stack Core2](https://shop.m5stack.com/products/m5stack-core2-esp32-iot-development-kit)
-* [M5Stamp C3](https://docs.m5stack.com/en/core/stamp_c3)
 * [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 Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
-* [Seeed LoRa-E5 Development Kit](https://www.seeedstudio.com/LoRa-E5-Dev-Kit-p-4868.html)
-* [Seeed Sipeed MAix BiT](https://www.seeedstudio.com/Sipeed-MAix-BiT-for-RISC-V-AI-IoT-p-2872.html)
-* [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html)
-* [SiFIve HiFive1 Rev B](https://www.sifive.com/boards/hifive1)
-* [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 "Nucleo" WL55JC](https://www.st.com/en/evaluation-tools/nucleo-wl55jc.html)
-* [ST Micro STM32F103XX "Bluepill"](https://stm32-base.org/boards/STM32F103C8T6-Blue-Pill)
+* [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 STM32F407 "Discovery"](https://www.st.com/en/evaluation-tools/stm32f4discovery.html)
-* [ST Micro STM32F469 "Discovery"](https://www.st.com/content/st_com/en/products/evaluation-tools/product-evaluation-tools/mcu-mpu-eval-tools/stm32-mcu-mpu-eval-tools/stm32-discovery-kits/32f469idiscovery.html)
 * [X9 Pro smartwatch](https://github.com/curtpw/nRF5x-device-reverse-engineering/tree/master/X9-nrf52832-activity-tracker/)
-* [The Things Industries Generic Node Sensor Edition](https://www.genericnode.com/docs/sensor-edition/)

 For more information, see [this list of boards](https://tinygo.org/microcontrollers/). Pull requests for additional support are welcome!

@@ -151,7 +103,7 @@ should arrive fairly quickly (under 1 min): https://invite.slack.golangbridge.or

 Your contributions are welcome!

-Please take a look at our [Contributing](https://tinygo.org/docs/guides/contributing/) page on our web site for details.
+Please take a look at our [CONTRIBUTING.md](./CONTRIBUTING.md) document for details.

 ## Project Scope

@@ -165,6 +117,7 @@ Goals:

 Non-goals:

+* Using more than one core.
 * Be efficient while using zillions of goroutines. However, good goroutine support is certainly a goal.
 * Be as fast as `gc`. However, LLVM will probably be better at optimizing certain things so TinyGo might actually turn out to be faster for number crunching.
 * Be able to compile every Go program out there.
@@ -183,6 +136,4 @@ The original reasoning was: if [Python](https://micropython.org/) can run on mic

 This project is licensed under the BSD 3-clause license, just like the [Go project](https://golang.org/LICENSE) itself.

-Some code has been copied from the LLVM project and is therefore licensed under [a variant of the Apache 2.0 license](http://releases.llvm.org/11.0.0/LICENSE.TXT). This has been clearly indicated in the header of these files.
-
-Some code has been copied and/or ported from Paul Stoffregen's Teensy libraries and is therefore licensed under PJRC's license. This has been clearly indicated in the header of these files.
+Some code has been copied from the LLVM project and is therefore licensed under [a variant of the Apache 2.0 license](http://releases.llvm.org/10.0.0/LICENSE.TXT). This has been clearly indicated in the header of these files.
@@ -0,0 +1,83 @@
+# Avoid lengthy LLVM rebuilds on each newly pushed branch. Pull requests will
+# be built anyway.
+trigger:
+- master
+- dev
+
+jobs:
+- job: Build
+  timeoutInMinutes: 240 # 4h
+  pool:
+    vmImage: 'VS2017-Win2016'
+  steps:
+    - task: GoTool@0
+      inputs:
+        version: '1.14.1'
+    - checkout: self
+    - task: CacheBeta@0
+      displayName: Cache LLVM source
+      inputs:
+        key: llvm-source-10-windows-v0
+        path: llvm-project
+    - task: Bash@3
+      displayName: Download LLVM source
+      inputs:
+        targetType: inline
+        script: make llvm-source
+    - task: CacheBeta@0
+      displayName: Cache LLVM build
+      inputs:
+        key: llvm-build-10-windows-v0
+        path: llvm-build
+    - task: Bash@3
+      displayName: Build LLVM
+      inputs:
+        targetType: inline
+        script: |
+          if [ ! -f llvm-build/lib/liblldELF.a ]
+          then
+            choco install ninja
+            make llvm-build
+          fi
+    - task: Bash@3
+      displayName: Install QEMU
+      inputs:
+        targetType: inline
+        script: choco install qemu
+    - task: CacheBeta@0
+      displayName: Cache wasi-libc sysroot
+      inputs:
+        key: wasi-libc-sysroot-v2
+        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 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
@@ -3,10 +3,8 @@ package builder
 import (
 	"bytes"
 	"debug/elf"
-	"debug/pe"
 	"encoding/binary"
 	"errors"
-	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -19,12 +17,17 @@ import (
 // given as a parameter. It is equivalent to the following command:
 //
 //     ar -rcs <archivePath> <objs...>
-func makeArchive(arfile *os.File, objs []string) error {
+func makeArchive(archivePath string, objs []string) error {
 	// Open the archive file.
-	arwriter := ar.NewWriter(arfile)
-	err := arwriter.WriteGlobalHeader()
+	arfile, err := os.Create(archivePath)
 	if err != nil {
-		return &os.PathError{Op: "write ar header", Path: arfile.Name(), Err: err}
+		return err
+	}
+	defer arfile.Close()
+	arwriter := ar.NewWriter(arfile)
+	err = arwriter.WriteGlobalHeader()
+	if err != nil {
+		return &os.PathError{"write ar header", archivePath, err}
 	}

 	// Open all object files and read the symbols for the symbol table.
@@ -32,55 +35,43 @@ func makeArchive(arfile *os.File, objs []string) error {
 		name      string // symbol name
 		fileIndex int    // index into objfiles
 	}{}
-	archiveOffsets := make([]int32, len(objs))
+	objfiles := make([]struct {
+		file          *os.File
+		archiveOffset 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.
-		if dbg, err := elf.NewFile(objfile); err == nil {
-			symbols, err := dbg.Symbols()
-			if err != nil {
-				return err
-			}
-			for _, symbol := range symbols {
-				bind := elf.ST_BIND(symbol.Info)
-				if bind != elf.STB_GLOBAL && bind != elf.STB_WEAK {
-					// Don't include local symbols (STB_LOCAL).
-					continue
-				}
-				if elf.ST_TYPE(symbol.Info) != elf.STT_FUNC && elf.ST_TYPE(symbol.Info) != elf.STT_OBJECT {
-					// Not a function.
-					continue
-				}
-				// Include in archive.
-				symbolTable = append(symbolTable, struct {
-					name      string
-					fileIndex int
-				}{symbol.Name, i})
-			}
-		} else if dbg, err := pe.NewFile(objfile); err == nil {
-			for _, symbol := range dbg.Symbols {
-				if symbol.StorageClass != 2 {
-					continue
-				}
-				if symbol.SectionNumber == 0 {
-					continue
-				}
-				symbolTable = append(symbolTable, struct {
-					name      string
-					fileIndex int
-				}{symbol.Name, i})
-			}
-		} else {
-			return fmt.Errorf("failed to open file %s as ELF or PE/COFF: %w", objpath, err)
+		dbg, err := elf.NewFile(objfile)
+		if err != nil {
+			return err
+		}
+		symbols, err := dbg.Symbols()
+		if err != nil {
+			return err
+		}
+		for _, symbol := range symbols {
+			bind := elf.ST_BIND(symbol.Info)
+			if bind != elf.STB_GLOBAL && bind != elf.STB_WEAK {
+				// Don't include local symbols (STB_LOCAL).
+				continue
+			}
+			if elf.ST_TYPE(symbol.Info) != elf.STT_FUNC {
+				// Not a function.
+				// TODO: perhaps globals variables should also be included?
+				continue
+			}
+			// Include in archive.
+			symbolTable = append(symbolTable, struct {
+				name      string
+				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.
@@ -134,14 +125,7 @@ func makeArchive(arfile *os.File, objs []string) error {
 	}

 	// Add all object files to the archive.
-	var copyBuf bytes.Buffer
-	for i, objpath := range objs {
-		objfile, err := os.Open(objpath)
-		if err != nil {
-			return err
-		}
-		defer objfile.Close()
-
+	for i, objfile := range objfiles {
 		// 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)
@@ -149,17 +133,17 @@ func makeArchive(arfile *os.File, objs []string) error {
 			return err
 		}
 		if int64(int32(offset)) != offset {
-			return errors.New("large archives (4GB+) not supported: " + arfile.Name())
+			return errors.New("large archives (4GB+) not supported: " + archivePath)
 		}
-		archiveOffsets[i] = int32(offset)
+		objfiles[i].archiveOffset = int32(offset)

 		// Write the file header.
-		st, err := objfile.Stat()
+		st, err := objfile.file.Stat()
 		if err != nil {
 			return err
 		}
 		err = arwriter.WriteHeader(&ar.Header{
-			Name:    filepath.Base(objfile.Name()),
+			Name:    filepath.Base(objfile.file.Name()),
 			ModTime: time.Unix(0, 0),
 			Uid:     0,
 			Gid:     0,
@@ -171,30 +155,22 @@ func makeArchive(arfile *os.File, objs []string) error {
 		}

 		// Copy the file contents into the archive.
-		// First load all contents into a buffer, then write it all in one go to
-		// the archive file. This is a bit complicated, but is necessary because
-		// io.Copy can't deal with files that are of an odd size.
-		copyBuf.Reset()
-		n, err := io.Copy(&copyBuf, objfile)
+		n, err := io.Copy(arwriter, objfile.file)
 		if err != nil {
-			return fmt.Errorf("could not copy object file into ar file: %w", err)
+			return err
 		}
 		if n != st.Size() {
-			return errors.New("file modified during ar creation: " + arfile.Name())
-		}
-		_, err = arwriter.Write(copyBuf.Bytes())
-		if err != nil {
-			return fmt.Errorf("could not copy object file into ar file: %w", err)
+			return errors.New("file modified during ar creation: " + archivePath)
 		}

 		// File is not needed anymore.
-		objfile.Close()
+		objfile.file.Close()
 	}

 	// Create symbol indices.
 	indicesBuf := &bytes.Buffer{}
 	for _, sym := range symbolTable {
-		err = binary.Write(indicesBuf, binary.BigEndian, archiveOffsets[sym.fileIndex])
+		err = binary.Write(indicesBuf, binary.BigEndian, objfiles[sym.fileIndex].archiveOffset)
 		if err != nil {
 			return err
 		}
@@ -0,0 +1,118 @@
+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)
+}
@@ -1,168 +0,0 @@
-package builder
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"runtime"
-	"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" and "target-features"
-// attributes match the CPU and Features 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", GOARM: "5"},
-		{GOOS: "linux", GOARCH: "arm", GOARM: "6"},
-		{GOOS: "linux", GOARCH: "arm", GOARM: "7"},
-		{GOOS: "linux", GOARCH: "arm64"},
-		{GOOS: "darwin", GOARCH: "amd64"},
-		{GOOS: "darwin", GOARCH: "arm64"},
-		{GOOS: "windows", GOARCH: "amd64"},
-	} {
-		name := "GOOS=" + options.GOOS + ",GOARCH=" + options.GOARCH
-		if options.GOARCH == "arm" {
-			name += ",GOARM=" + options.GOARM
-		}
-		t.Run(name, 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" and "target-features" string attribute of the add
-	// function.
-	add := mod.NamedFunction("add")
-	var cpu, features string
-	cpuAttr := add.GetStringAttributeAtIndex(-1, "target-cpu")
-	featuresAttr := add.GetStringAttributeAtIndex(-1, "target-features")
-	if !cpuAttr.IsNil() {
-		cpu = cpuAttr.GetStringValue()
-	}
-	if !featuresAttr.IsNil() {
-		features = featuresAttr.GetStringValue()
-	}
-	if cpu != config.CPU() {
-		t.Errorf("target has CPU %#v but Clang makes it CPU %#v", config.CPU(), cpu)
-	}
-	if features != config.Features() {
-		if hasBuiltinTools || runtime.GOOS != "linux" {
-			// Skip this step when using an external Clang invocation on Linux.
-			// The reason is that Debian has patched Clang in a way that
-			// modifies the LLVM features string, changing lots of FPU/float
-			// related flags. We want to test vanilla Clang, not Debian Clang.
-			t.Errorf("target has LLVM features\n\t%#v\nbut Clang makes it\n\t%#v", config.Features(), features)
-		}
-	}
-}
-
-// 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())
-}
@@ -1,93 +0,0 @@
-package builder
-
-import (
-	"bytes"
-	"debug/elf"
-	"debug/macho"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"os"
-	"runtime"
-)
-
-// ReadBuildID reads the build ID from the currently running executable.
-func ReadBuildID() ([]byte, error) {
-	executable, err := os.Executable()
-	if err != nil {
-		return nil, err
-	}
-	f, err := os.Open(executable)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	switch runtime.GOOS {
-	case "linux", "freebsd":
-		// Read the GNU build id section. (Not sure about FreeBSD though...)
-		file, err := elf.NewFile(f)
-		if err != nil {
-			return nil, err
-		}
-		for _, section := range file.Sections {
-			if section.Type != elf.SHT_NOTE ||
-				(section.Name != ".note.gnu.build-id" && section.Name != ".note.go.buildid") {
-				continue
-			}
-			buf := make([]byte, section.Size)
-			n, err := section.ReadAt(buf, 0)
-			if uint64(n) != section.Size || err != nil {
-				return nil, fmt.Errorf("could not read build id: %w", err)
-			}
-			return buf, nil
-		}
-	case "darwin":
-		// Read the LC_UUID load command, which contains the equivalent of a
-		// build ID.
-		file, err := macho.NewFile(f)
-		if err != nil {
-			return nil, err
-		}
-		for _, load := range file.Loads {
-			// Unfortunately, the debug/macho package doesn't support the
-			// LC_UUID command directly. So we have to read it from
-			// macho.LoadBytes.
-			load, ok := load.(macho.LoadBytes)
-			if !ok {
-				continue
-			}
-			raw := load.Raw()
-			command := binary.LittleEndian.Uint32(raw)
-			if command != 0x1b {
-				// Looking for the LC_UUID load command.
-				// LC_UUID is defined here as 0x1b:
-				// https://opensource.apple.com/source/xnu/xnu-4570.71.2/EXTERNAL_HEADERS/mach-o/loader.h.auto.html
-				continue
-			}
-			return raw[4:], nil
-		}
-	default:
-		// On other platforms (such as Windows) there isn't such a convenient
-		// build ID. Luckily, Go does have an equivalent of the build ID, which
-		// is stored as a special symbol named go.buildid. You can read it
-		// using `go tool buildid`, but the code below extracts it directly
-		// from the binary.
-		// Unfortunately, because of stripping with the -w flag, no symbol
-		// table might be available. Therefore, we have to scan the binary
-		// directly. Luckily the build ID is always at the start of the file.
-		// For details, see:
-		// https://github.com/golang/go/blob/master/src/cmd/internal/buildid/buildid.go
-		fileStart := make([]byte, 4096)
-		_, err := io.ReadFull(f, fileStart)
-		index := bytes.Index(fileStart, []byte("\xff Go build ID: \""))
-		if index < 0 || index > len(fileStart)-103 {
-			return nil, fmt.Errorf("could not find build id in %s", err)
-		}
-		buf := fileStart[index : index+103]
-		if bytes.HasPrefix(buf, []byte("\xff Go build ID: \"")) && bytes.HasSuffix(buf, []byte("\"\n \xff")) {
-			return buf[len("\xff Go build ID: \"") : len(buf)-1], nil
-		}
-	}
-	return nil, fmt.Errorf("could not find build ID in %s", executable)
-}
@@ -157,12 +157,10 @@ var aeabiBuiltins = []string{
 //
 // For more information, see: https://compiler-rt.llvm.org/
 var CompilerRT = Library{
-	name: "compiler-rt",
-	cflags: func(target, headerPath string) []string {
-		return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"}
-	},
+	name:      "compiler-rt",
+	cflags:    func() []string { return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"} },
 	sourceDir: "lib/compiler-rt/lib/builtins",
-	librarySources: func(target string) []string {
+	sources: func(target string) []string {
 		builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
 		if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
 			builtins = append(builtins, aeabiBuiltins...)
@@ -1,317 +0,0 @@
-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
-	}
-
-	// Acquire a lock (if supported).
-	unlock := lock(filepath.Join(goenv.Get("GOCACHE"), fileHash+".c.lock"))
-	defer unlock()
-
-	// 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
-}
@@ -101,7 +101,7 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,

  // Target Options
  Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
-  Opts.CPU = std::string(Args.getLastArgValue(OPT_target_cpu));
+  Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
  Opts.Features = Args.getAllArgValues(OPT_target_feature);

  // Use the default target triple if unspecified.
@@ -115,33 +115,30 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
  // Any DebugInfoKind implies GenDwarfForAssembly.
  Opts.GenDwarfForAssembly = Args.hasArg(OPT_debug_info_kind_EQ);

-  if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections_EQ)) {
-    Opts.CompressDebugSections =
-        llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
-            .Case("none", llvm::DebugCompressionType::None)
-            .Case("zlib", llvm::DebugCompressionType::Z)
-            .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
-            .Default(llvm::DebugCompressionType::None);
+  if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,
+                                     OPT_compress_debug_sections_EQ)) {
+    if (A->getOption().getID() == OPT_compress_debug_sections) {
+      // TODO: be more clever about the compression type auto-detection
+      Opts.CompressDebugSections = llvm::DebugCompressionType::GNU;
+    } else {
+      Opts.CompressDebugSections =
+          llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
+              .Case("none", llvm::DebugCompressionType::None)
+              .Case("zlib", llvm::DebugCompressionType::Z)
+              .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
+              .Default(llvm::DebugCompressionType::None);
+    }
  }

  Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
-  if (auto *DwarfFormatArg = Args.getLastArg(OPT_gdwarf64, OPT_gdwarf32))
-    Opts.Dwarf64 = DwarfFormatArg->getOption().matches(OPT_gdwarf64);
  Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 2, Diags);
-  Opts.DwarfDebugFlags =
-      std::string(Args.getLastArgValue(OPT_dwarf_debug_flags));
-  Opts.DwarfDebugProducer =
-      std::string(Args.getLastArgValue(OPT_dwarf_debug_producer));
-  if (const Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
-                                     options::OPT_fdebug_compilation_dir_EQ))
-    Opts.DebugCompilationDir = A->getValue();
-  Opts.MainFileName = std::string(Args.getLastArgValue(OPT_main_file_name));
+  Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
+  Opts.DwarfDebugProducer = Args.getLastArgValue(OPT_dwarf_debug_producer);
+  Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
+  Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);

-  for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
-    auto Split = StringRef(Arg).split('=');
-    Opts.DebugPrefixMap.insert(
-        {std::string(Split.first), std::string(Split.second)});
-  }
+  for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
+    Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));

  // Frontend Options
  if (Args.hasArg(OPT_INPUT)) {
@@ -157,9 +154,8 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
    }
  }
  Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
-  Opts.OutputPath = std::string(Args.getLastArgValue(OPT_o));
-  Opts.SplitDwarfOutput =
-      std::string(Args.getLastArgValue(OPT_split_dwarf_output));
+  Opts.OutputPath = Args.getLastArgValue(OPT_o);
+  Opts.SplitDwarfOutput = Args.getLastArgValue(OPT_split_dwarf_output);
  if (Arg *A = Args.getLastArg(OPT_filetype)) {
    StringRef Name = A->getValue();
    unsigned OutputType = StringSwitch<unsigned>(Name)
@@ -187,9 +183,8 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
  Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
  Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
  Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
-  Opts.RelocationModel =
-      std::string(Args.getLastArgValue(OPT_mrelocation_model, "pic"));
-  Opts.TargetABI = std::string(Args.getLastArgValue(OPT_target_abi));
+  Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
+  Opts.TargetABI = Args.getLastArgValue(OPT_target_abi);
  Opts.IncrementalLinkerCompatible =
      Args.hasArg(OPT_mincremental_linker_compatible);
  Opts.SymbolDefs = Args.getAllArgValues(OPT_defsym);
@@ -216,7 +211,7 @@ getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {

  std::error_code EC;
  auto Out = std::make_unique<raw_fd_ostream>(
-      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_TextWithCRLF));
+      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_Text));
  if (EC) {
    Diags.Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
    return nullptr;
@@ -225,8 +220,7 @@ getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
  return Out;
 }

-static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
-                                 DiagnosticsEngine &Diags) {
+bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
  // Get the target specific parser.
  std::string Error;
  const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
@@ -234,7 +228,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
    return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;

  ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
-      MemoryBuffer::getFileOrSTDIN(Opts.InputFile, /*IsText=*/true);
+      MemoryBuffer::getFileOrSTDIN(Opts.InputFile);

  if (std::error_code EC = Buffer.getError()) {
    Error = EC.message();
@@ -275,15 +269,11 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
  if (!Opts.SplitDwarfOutput.empty())
    DwoOS = getOutputStream(Opts.SplitDwarfOutput, Diags, IsBinary);

-  // Build up the feature string from the target feature list.
-  std::string FS = llvm::join(Opts.Features, ",");
+  // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
+  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
+  std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());

-  std::unique_ptr<MCSubtargetInfo> STI(
-      TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));
-  assert(STI && "Unable to create subtarget info!");
-
-  MCContext Ctx(Triple(Opts.Triple), MAI.get(), MRI.get(), STI.get(), &SrcMgr,
-                &MCOptions);
+  MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr, &MCOptions);

  bool PIC = false;
  if (Opts.RelocationModel == "static") {
@@ -296,12 +286,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
    PIC = false;
  }

-  // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
-  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
-  std::unique_ptr<MCObjectFileInfo> MOFI(
-      TheTarget->createMCObjectFileInfo(Ctx, PIC));
-  Ctx.setObjectFileInfo(MOFI.get());
-
+  MOFI->InitMCObjectFileInfo(Triple(Opts.Triple), PIC, Ctx);
  if (Opts.SaveTemporaryLabels)
    Ctx.setAllowTemporaryLabels(false);
  if (Opts.GenDwarfForAssembly)
@@ -323,16 +308,24 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
      Ctx.addDebugPrefixMapEntry(KV.first, KV.second);
  if (!Opts.MainFileName.empty())
    Ctx.setMainFileName(StringRef(Opts.MainFileName));
-  Ctx.setDwarfFormat(Opts.Dwarf64 ? dwarf::DWARF64 : dwarf::DWARF32);
  Ctx.setDwarfVersion(Opts.DwarfVersion);
  if (Opts.GenDwarfForAssembly)
    Ctx.setGenDwarfRootFile(Opts.InputFile,
                            SrcMgr.getMemoryBuffer(BufferIndex)->getBuffer());

+  // Build up the feature string from the target feature list.
+  std::string FS;
+  if (!Opts.Features.empty()) {
+    FS = Opts.Features[0];
+    for (unsigned i = 1, e = Opts.Features.size(); i != e; ++i)
+      FS += "," + Opts.Features[i];
+  }
+
  std::unique_ptr<MCStreamer> Str;

  std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
-  assert(MCII && "Unable to create instruction info!");
+  std::unique_ptr<MCSubtargetInfo> STI(
+      TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));

  raw_pwrite_stream *Out = FDOS.get();
  std::unique_ptr<buffer_ostream> BOS;
@@ -371,8 +364,6 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
        TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
    std::unique_ptr<MCAsmBackend> MAB(
        TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
-    assert(MAB && "Unable to create asm backend!");
-
    std::unique_ptr<MCObjectWriter> OW =
        DwoOS ? MAB->createDwoObjectWriter(*Out, *DwoOS)
              : MAB->createObjectWriter(*Out);
@@ -387,11 +378,12 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,

  // When -fembed-bitcode is passed to clang_as, a 1-byte marker
  // is emitted in __LLVM,__asm section if the object file is MachO format.
-  if (Opts.EmbedBitcode && Ctx.getObjectFileType() == MCContext::IsMachO) {
+  if (Opts.EmbedBitcode && Ctx.getObjectFileInfo()->getObjectFileType() ==
+                               MCObjectFileInfo::IsMachO) {
    MCSection *AsmLabel = Ctx.getMachOSection(
        "__LLVM", "__asm", MachO::S_REGULAR, 4, SectionKind::getReadOnly());
    Str.get()->SwitchSection(AsmLabel);
-    Str.get()->emitZeros(1);
+    Str.get()->EmitZeros(1);
  }

  // Assembly to object compilation should leverage assembly info.
@@ -424,12 +416,12 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
    Failed = Parser->Run(Opts.NoInitialTextSection);
  }

-  return Failed;
-}
-
-bool ExecuteAssembler(AssemblerInvocation &Opts,
-                             DiagnosticsEngine &Diags) {
-  bool Failed = ExecuteAssemblerImpl(Opts, Diags);
+  // Close Streamer first.
+  // It might have a reference to the output stream.
+  Str.reset();
+  // Close the output stream early.
+  BOS.reset();
+  FDOS.reset();

  // Delete output file if there were errors.
  if (Failed) {
@@ -477,7 +469,7 @@ int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
    return 1;

  if (Asm.ShowHelp) {
-    getDriverOptTable().printHelp(
+    getDriverOptTable().PrintHelp(
        llvm::outs(), "clang -cc1as [options] file...",
        "Clang Integrated Assembler",
        /*Include=*/driver::options::CC1AsOption, /*Exclude=*/0,
@@ -39,7 +39,6 @@ struct AssemblerInvocation {
  unsigned SaveTemporaryLabels : 1;
  unsigned GenDwarfForAssembly : 1;
  unsigned RelaxELFRelocations : 1;
-  unsigned Dwarf64 : 1;
  unsigned DwarfVersion;
  std::string DwarfDebugFlags;
  std::string DwarfDebugProducer;
@@ -109,7 +108,6 @@ public:
    FatalWarnings = 0;
    NoWarn = 0;
    IncrementalLinkerCompatible = 0;
-    Dwarf64 = 0;
    DwarfVersion = 0;
    EmbedBitcode = 0;
  }
@@ -1,33 +0,0 @@
-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
-		}
-	}
-}
@@ -11,7 +11,6 @@
 #include <clang/FrontendTool/Utils.h>
 #include <llvm/ADT/IntrusiveRefCntPtr.h>
 #include <llvm/Option/Option.h>
-#include <llvm/Support/Host.h>

 using namespace llvm;
 using namespace clang;
@@ -2,7 +2,6 @@ package builder

 import (
 	"errors"
-	"fmt"
 	"os"
 	"os/exec"
 	"runtime"
@@ -22,24 +21,13 @@ 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" {
-		var prefix string
-		switch runtime.GOARCH {
-		case "amd64":
-			prefix = "/usr/local/opt/llvm@" + llvmMajor + "/bin/"
-		case "arm64":
-			prefix = "/opt/homebrew/opt/llvm@" + llvmMajor + "/bin/"
-		default:
-			// unknown GOARCH
-			panic(fmt.Sprintf("unknown GOARCH: %s on darwin", runtime.GOARCH))
-		}
+		prefix := "/usr/local/opt/llvm@" + llvmMajor + "/bin/"
 		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
@@ -48,7 +36,6 @@ 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" {
@@ -56,34 +43,23 @@ 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")
 	}
 }

-// 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)
+func execCommand(cmdNames []string, args ...string) error {
+	for _, cmdName := range cmdNames {
+		cmd := exec.Command(cmdName, args...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err := cmd.Run()
 		if err != nil {
-			if errors.Unwrap(err) == exec.ErrNotFound {
+			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
 				continue
 			}
-			return cmdName, err
+			return err
 		}
-		return cmdName, nil
+		return nil
 	}
-	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()
+	return errors.New("none of these commands were found in your $PATH: " + strings.Join(cmdNames, " "))
 }
@@ -13,32 +13,22 @@ 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)
+	spec, err := compileopts.LoadTarget(options.Target)
 	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)
+	major, minor, err := getGorootVersion(goroot)
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}
-	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)
+	if major != 1 || minor < 11 || minor > 14 {
+		return nil, fmt.Errorf("requires go version 1.11, 1.12, 1.13, or 1.14, got go%d.%d", major, minor)
 	}
-
 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
-
 	return &compileopts.Config{
 		Options:        options,
 		Target:         spec,
@@ -1,57 +0,0 @@
-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
-}
@@ -1,16 +1,71 @@
 package builder

 import (
+	"errors"
+	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"sort"
 	"strings"
-
-	"tinygo.org/x/go-llvm"
 )

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

 	// It looks like we are built with a system-installed LLVM. Do a last
 	// attempt: try to use Clang headers relative to the clang binary.
-	llvmMajor := strings.Split(llvm.Version, ".")[0]
 	for _, cmdName := range commands["clang"] {
 		binpath, err := exec.LookPath(cmdName)
 		if err == nil {
@@ -44,38 +98,22 @@ func getClangHeaderPath(TINYGOROOT string) string {
 			// Example executable:
 			//     /usr/lib/llvm-9/bin/clang
 			// Example include path:
-			//     /usr/lib/llvm-9/lib64/clang/9.0.1/include/
-			llvmRoot := filepath.Dir(filepath.Dir(binpath))
-			clangVersionRoot := filepath.Join(llvmRoot, "lib64", "clang")
-			dirs64, err64 := ioutil.ReadDir(clangVersionRoot)
-			// Example include path:
 			//     /usr/lib/llvm-9/lib/clang/9.0.1/include/
-			clangVersionRoot = filepath.Join(llvmRoot, "lib", "clang")
-			dirs32, err32 := ioutil.ReadDir(clangVersionRoot)
-			if err64 != nil && err32 != nil {
+			llvmRoot := filepath.Dir(filepath.Dir(binpath))
+			clangVersionRoot := filepath.Join(llvmRoot, "lib", "clang")
+			dirs, err := ioutil.ReadDir(clangVersionRoot)
+			if err != nil {
 				// Unexpected.
 				continue
 			}
-			dirnames := make([]string, len(dirs64)+len(dirs32))
-			dirCount := 0
-			for _, d := range dirs32 {
-				name := d.Name()
-				if name == llvmMajor || strings.HasPrefix(name, llvmMajor+".") {
-					dirnames[dirCount] = filepath.Join(llvmRoot, "lib", "clang", name)
-					dirCount++
-				}
-			}
-			for _, d := range dirs64 {
-				name := d.Name()
-				if name == llvmMajor || strings.HasPrefix(name, llvmMajor+".") {
-					dirnames[dirCount] = filepath.Join(llvmRoot, "lib64", "clang", name)
-					dirCount++
-				}
+			dirnames := make([]string, len(dirs))
+			for i, d := range dirs {
+				dirnames[i] = d.Name()
 			}
 			sort.Strings(dirnames)
 			// Check for the highest version first.
-			for i := dirCount - 1; i >= 0; i-- {
-				path := filepath.Join(dirnames[i], "include")
+			for i := len(dirnames) - 1; i >= 0; i-- {
+				path := filepath.Join(clangVersionRoot, dirnames[i], "include")
 				_, err := os.Stat(filepath.Join(path, "stdint.h"))
 				if err == nil {
 					return path
@@ -84,20 +122,6 @@ func getClangHeaderPath(TINYGOROOT string) string {
 		}
 	}

-	// On Arch Linux, the clang executable is stored in /usr/bin rather than being symlinked from there.
-	// Search directly in /usr/lib for clang.
-	if matches, err := filepath.Glob("/usr/lib/clang/" + llvmMajor + ".*.*"); err == nil {
-		// Check for the highest version first.
-		sort.Strings(matches)
-		for i := len(matches) - 1; i >= 0; i-- {
-			path := filepath.Join(matches[i], "include")
-			_, err := os.Stat(filepath.Join(path, "stdint.h"))
-			if err == nil {
-				return path
-			}
-		}
-	}
-
 	// Could not find it.
 	return ""
 }
@@ -1,166 +0,0 @@
-package builder
-
-// This file implements support for writing ESP image files. These image files
-// are read by the ROM bootloader so have to be in a particular format.
-//
-// In the future, it may be necessary to implement support for other image
-// formats, such as the ESP8266 image formats (again, used by the ROM bootloader
-// to load the firmware).
-
-import (
-	"bytes"
-	"crypto/sha256"
-	"debug/elf"
-	"encoding/binary"
-	"fmt"
-	"io/ioutil"
-	"sort"
-)
-
-type espImageSegment struct {
-	addr uint32
-	data []byte
-}
-
-// makeESPFirmare converts an input ELF file to an image file for an ESP32 or
-// ESP8266 chip. This is a special purpose image format just for the ESP chip
-// family, and is parsed by the on-chip mask ROM bootloader.
-//
-// The following documentation has been used:
-// https://github.com/espressif/esptool/wiki/Firmware-Image-Format
-// https://github.com/espressif/esp-idf/blob/8fbb63c2a701c22ccf4ce249f43aded73e134a34/components/bootloader_support/include/esp_image_format.h#L58
-// https://github.com/espressif/esptool/blob/master/esptool.py
-func makeESPFirmareImage(infile, outfile, format string) error {
-	inf, err := elf.Open(infile)
-	if err != nil {
-		return err
-	}
-	defer inf.Close()
-
-	// Load all segments to be written to the image. These are actually ELF
-	// sections, not true ELF segments (similar to how esptool does it).
-	var segments []*espImageSegment
-	for _, section := range inf.Sections {
-		if section.Type != elf.SHT_PROGBITS || section.Size == 0 || section.Flags&elf.SHF_ALLOC == 0 {
-			continue
-		}
-		data, err := section.Data()
-		if err != nil {
-			return fmt.Errorf("failed to read section data: %w", err)
-		}
-		for len(data)%4 != 0 {
-			// Align segment to 4 bytes.
-			data = append(data, 0)
-		}
-		if uint64(uint32(section.Addr)) != section.Addr {
-			return fmt.Errorf("section address too big: 0x%x", section.Addr)
-		}
-		segments = append(segments, &espImageSegment{
-			addr: uint32(section.Addr),
-			data: data,
-		})
-	}
-
-	// Sort the segments by address. This is what esptool does too.
-	sort.SliceStable(segments, func(i, j int) bool { return segments[i].addr < segments[j].addr })
-
-	// Calculate checksum over the segment data. This is used in the image
-	// footer.
-	checksum := uint8(0xef)
-	for _, segment := range segments {
-		for _, b := range segment.data {
-			checksum ^= b
-		}
-	}
-
-	// Write first to an in-memory buffer, primarily so that we can easily
-	// calculate a hash over the entire image.
-	// 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", "esp32c3":
-		// Header format:
-		// 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
-			spi_mode       uint8
-			spi_speed_size uint8
-			entry_addr     uint32
-			wp_pin         uint8
-			spi_pin_drv    [3]uint8
-			chip_id        uint16
-			min_chip_rev   uint8
-			reserved       [8]uint8
-			hash_appended  bool
-		}{
-			magic:          0xE9,
-			segment_count:  byte(len(segments)),
-			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":
-		// Header format:
-		// https://github.com/espressif/esptool/wiki/Firmware-Image-Format
-		// Basically a truncated version of the ESP32 header.
-		binary.Write(outf, binary.LittleEndian, struct {
-			magic          uint8
-			segment_count  uint8
-			spi_mode       uint8
-			spi_speed_size uint8
-			entry_addr     uint32
-		}{
-			magic:          0xE9,
-			segment_count:  byte(len(segments)),
-			spi_mode:       0,    // irrelevant, replaced by esptool when flashing
-			spi_speed_size: 0x20, // spi_speed, spi_size: replaced by esptool when flashing
-			entry_addr:     uint32(inf.Entry),
-		})
-	default:
-		return fmt.Errorf("builder: unknown binary format %#v, expected esp32 or esp8266", format)
-	}
-
-	// Write all segments to the image.
-	// https://github.com/espressif/esptool/wiki/Firmware-Image-Format#segment
-	for _, segment := range segments {
-		binary.Write(outf, binary.LittleEndian, struct {
-			addr   uint32
-			length uint32
-		}{
-			addr:   segment.addr,
-			length: uint32(len(segment.data)),
-		})
-		outf.Write(segment.data)
-	}
-
-	// Footer, including checksum.
-	// The entire image size must be a multiple of 16, so pad the image to one
-	// byte less than that before writing the checksum.
-	outf.Write(make([]byte, 15-outf.Len()%16))
-	outf.WriteByte(checksum)
-
-	if format != "esp8266" {
-		// SHA256 hash (to protect against image corruption, not for security).
-		hash := sha256.Sum256(outf.Bytes())
-		outf.Write(hash[:])
-	}
-
-	// Write the image to the output file.
-	return ioutil.WriteFile(outfile, outf.Bytes(), 0666)
-}
@@ -1,229 +0,0 @@
-package builder
-
-// This file implements a job runner for the compiler, which runs jobs in
-// parallel while taking care of dependencies.
-
-import (
-	"container/heap"
-	"errors"
-	"fmt"
-	"runtime"
-	"sort"
-	"strings"
-	"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)
-	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,
-	}
-}
-
-// 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, sema chan struct{}) error {
-	if sema == nil {
-		// Have a default, if the semaphore isn't set. This is useful for
-		// tests.
-		sema = make(chan struct{}, runtime.NumCPU())
-	}
-	if cap(sema) == 0 {
-		return errors.New("cannot 0 jobs at a time")
-	}
-
-	// 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)
-
-	waiting := make(map[*compileJob]map[*compileJob]struct{}, len(jobs))
-	dependents := make(map[*compileJob][]*compileJob, len(jobs))
-	jidx := make(map[*compileJob]int)
-	var ready intHeap
-	for i, job := range jobs {
-		jidx[job] = i
-		if len(job.dependencies) == 0 {
-			// This job is ready to run.
-			ready.Push(i)
-			continue
-		}
-
-		// Construct a map for dependencies which the job is currently waiting on.
-		waitDeps := make(map[*compileJob]struct{})
-		waiting[job] = waitDeps
-
-		// Add the job to the dependents list of each dependency.
-		for _, dep := range job.dependencies {
-			dependents[dep] = append(dependents[dep], job)
-			waitDeps[dep] = struct{}{}
-		}
-	}
-
-	// Create a channel to accept notifications of completion.
-	doneChan := make(chan *compileJob)
-
-	// 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 len(ready.IntSlice) > 0 || numRunningJobs != 0 {
-		var completed *compileJob
-		if len(ready.IntSlice) > 0 {
-			select {
-			case sema <- struct{}{}:
-				// Start a job.
-				job := jobs[heap.Pop(&ready).(int)]
-				if jobRunnerDebug {
-					fmt.Println("## start:   ", job.description)
-				}
-				go runJob(job, doneChan)
-				numRunningJobs++
-				continue
-
-			case completed = <-doneChan:
-				// A job completed.
-			}
-		} else {
-			// Wait for a job to complete.
-			completed = <-doneChan
-		}
-		numRunningJobs--
-		<-sema
-		if jobRunnerDebug {
-			fmt.Println("## finished:", job.description, "(time "+job.duration.String()+")")
-		}
-		if completed.err != nil {
-			// Wait for any current jobs to finish.
-			for numRunningJobs != 0 {
-				<-doneChan
-				numRunningJobs--
-			}
-
-			// The build failed.
-			return completed.err
-		}
-
-		// Update total run time.
-		totalTime += completed.duration
-
-		// Update dependent jobs.
-		for _, j := range dependents[completed] {
-			wait := waiting[j]
-			delete(wait, completed)
-			if len(wait) == 0 {
-				// This job is now ready to run.
-				ready.Push(jidx[j])
-				delete(waiting, j)
-			}
-		}
-	}
-	if len(waiting) != 0 {
-		// There is a dependency cycle preventing some jobs from running.
-		return errDependencyCycle{waiting}
-	}
-
-	// 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
-}
-
-type errDependencyCycle struct {
-	waiting map[*compileJob]map[*compileJob]struct{}
-}
-
-func (err errDependencyCycle) Error() string {
-	waits := make([]string, 0, len(err.waiting))
-	for j, wait := range err.waiting {
-		deps := make([]string, 0, len(wait))
-		for dep := range wait {
-			deps = append(deps, dep.description)
-		}
-		sort.Strings(deps)
-
-		waits = append(waits, fmt.Sprintf("\t%s is waiting for [%s]",
-			j.description, strings.Join(deps, ", "),
-		))
-	}
-	sort.Strings(waits)
-	return "deadlock:\n" + strings.Join(waits, "\n")
-}
-
-type intHeap struct {
-	sort.IntSlice
-}
-
-func (h *intHeap) Push(x interface{}) {
-	h.IntSlice = append(h.IntSlice, x.(int))
-}
-
-func (h *intHeap) Pop() interface{} {
-	x := h.IntSlice[len(h.IntSlice)-1]
-	h.IntSlice = h.IntSlice[:len(h.IntSlice)-1]
-	return x
-}
-
-// runJob runs a compile job and notifies doneChan of completion.
-func runJob(job *compileJob, doneChan chan *compileJob) {
-	start := time.Now()
-	if job.run != nil {
-		err := job.run(job)
-		if err != nil {
-			job.err = err
-		}
-	}
-	job.duration = time.Since(start)
-	doneChan <- job
-}
@@ -4,11 +4,8 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
-	"sync"

-	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
 )

@@ -18,230 +15,88 @@ type Library struct {
 	// The library name, such as compiler-rt or picolibc.
 	name 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
+	cflags func() []string

 	// The source directory, relative to TINYGOROOT.
 	sourceDir string

 	// The source files, relative to sourceDir.
-	librarySources func(target string) []string
+	sources func(target string) []string
+}

-	// The source code for the crt1.o file, relative to sourceDir.
-	crt1Source 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
 }

 // Load the library archive, possibly generating and caching it if needed.
-// 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, unlock, err := l.load(config, tmpdir)
-	if err != nil {
-		return "", err
-	}
-	defer unlock()
-	err = runJobs(job, config.Options.Semaphore)
-	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, abortLock func(), err error) {
-	outdir, precompiled := config.LibcPath(l.name)
-	archiveFilePath := filepath.Join(outdir, "lib.a")
-	if precompiled {
+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 dummyCompileJob(archiveFilePath), func() {}, nil
+		return precompiledPath, nil
 	}

-	// Create a lock on the output (if supported).
-	// This is a bit messy, but avoids a deadlock because it is ordered consistently with other library loads within a build.
-	outname := filepath.Base(outdir)
-	unlock := lock(filepath.Join(goenv.Get("GOCACHE"), outname+".lock"))
-	var ok bool
-	defer func() {
-		if !ok {
-			unlock()
-		}
-	}()
+	outfile := l.name + "-" + target + ".a"

 	// Try to fetch this library from the cache.
-	if _, err := os.Stat(archiveFilePath); err == nil {
-		return dummyCompileJob(archiveFilePath), func() {}, nil
+	if path, err := cacheLoad(outfile, commands["clang"][0], l.sourcePaths(target)); path != "" || err != nil {
+		// Cache hit.
+		return path, err
 	}
 	// Cache miss, build it now.

-	// Create the destination directory where the components of this library
-	// (lib.a file, include directory) are placed.
-	err = os.MkdirAll(filepath.Join(goenv.Get("GOCACHE"), outname), 0o777)
+	dirPrefix := "tinygo-" + l.name
+	remapDir := filepath.Join(os.TempDir(), dirPrefix)
+	dir, err := ioutil.TempDir(os.TempDir(), dirPrefix)
 	if err != nil {
-		// Could not create directory (and not because it already exists).
-		return nil, 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, nil, err
-			}
-			defer os.RemoveAll(temporaryHeaderPath)
-			err = l.makeHeaders(target, temporaryHeaderPath)
-			if err != nil {
-				return nil, nil, err
-			}
-			err = os.Rename(temporaryHeaderPath, headerPath)
-			if err != nil {
-				switch {
-				case os.IsExist(err):
-					// Another invocation of TinyGo also seems to have already created the headers.
-
-				case runtime.GOOS == "windows" && os.IsPermission(err):
-					// On Windows, a rename with a destination directory that already
-					// exists does not result in an IsExist error, but rather in an
-					// access denied error. To be sure, check for this case by checking
-					// whether the target directory exists.
-					if _, err := os.Stat(headerPath); err == nil {
-						break
-					}
-					fallthrough
-
-				default:
-					return nil, 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, nil, err
+		return "", err
 	}
+	defer os.RemoveAll(dir)

 	// Precalculate the flags to the compiler invocation.
-	// 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)
-		}
-	}
+	args := append(l.cflags(), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
 	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
-		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft", "-fno-unwind-tables")
+		args = append(args, "-fshort-enums", "-fomit-frame-pointer")
 	}
 	if strings.HasPrefix(target, "riscv32-") {
 		args = append(args, "-march=rv32imac", "-mabi=ilp32", "-fforce-enable-int128")
 	}
-	if strings.HasPrefix(target, "riscv64-") {
-		args = append(args, "-march=rv64gc", "-mabi=lp64")
-	}

-	var once sync.Once
-
-	// Create job to put all the object files in a single archive. This archive
-	// file is the (static) library file.
+	// Compile all sources.
 	var objs []string
-	job = &compileJob{
-		description: "ar " + l.name + "/lib.a",
-		result:      filepath.Join(goenv.Get("GOCACHE"), outname, "lib.a"),
-		run: func(*compileJob) error {
-			defer once.Do(unlock)
-
-			// 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)
+	for _, srcpath := range l.sourcePaths(target) {
+		objpath := filepath.Join(dir, filepath.Base(srcpath)+".o")
 		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
-			},
-		})
+		// 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}
+		}
 	}

-	// 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"))
-			},
-		})
+	// 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
 	}

-	ok = true
-	return job, func() {
-		once.Do(unlock)
-	}, nil
+	// Store this archive in the cache.
+	return cacheStore(arpath, outfile, commands["clang"][0], l.sourcePaths(target))
 }
@@ -11,11 +11,6 @@ bool tinygo_link_elf(int argc, char **argv) {
 	return lld::elf::link(args, false, llvm::outs(), llvm::errs());
 }

-bool tinygo_link_mingw(int argc, char **argv) {
-	std::vector<const char*> args(argv, argv + argc);
-	return lld::mingw::link(args, false, llvm::outs(), llvm::errs());
-}
-
 bool tinygo_link_wasm(int argc, char **argv) {
 	std::vector<const char*> args(argv, argv + argc);
 	return lld::wasm::link(args, false, llvm::outs(), llvm::errs());
@@ -1,91 +0,0 @@
-package builder
-
-import (
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-var MinGW = Library{
-	name: "mingw-w64",
-	makeHeaders: func(target, includeDir string) error {
-		// copy _mingw.h
-		srcDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib", "mingw-w64")
-		outf, err := os.Create(includeDir + "/_mingw.h")
-		if err != nil {
-			return err
-		}
-		defer outf.Close()
-		inf, err := os.Open(srcDir + "/mingw-w64-headers/crt/_mingw.h.in")
-		if err != nil {
-			return err
-		}
-		_, err = io.Copy(outf, inf)
-		return err
-	},
-	cflags: func(target, headerPath string) []string {
-		// No flags necessary because there are no files to compile.
-		return nil
-	},
-	librarySources: func(target string) []string {
-		// We only use the UCRT DLL file. No source files necessary.
-		return nil
-	},
-}
-
-// makeMinGWExtraLibs returns a slice of jobs to import the correct .dll
-// libraries. This is done by converting input .def files to .lib files which
-// can then be linked as usual.
-//
-// TODO: cache the result. At the moment, it costs a few hundred milliseconds to
-// compile these files.
-func makeMinGWExtraLibs(tmpdir string) []*compileJob {
-	var jobs []*compileJob
-	root := goenv.Get("TINYGOROOT")
-	// Normally all the api-ms-win-crt-*.def files are all compiled to a single
-	// .lib file. But to simplify things, we're going to leave them as separate
-	// files.
-	for _, name := range []string{
-		"kernel32.def.in",
-		"api-ms-win-crt-conio-l1-1-0.def",
-		"api-ms-win-crt-convert-l1-1-0.def",
-		"api-ms-win-crt-environment-l1-1-0.def",
-		"api-ms-win-crt-filesystem-l1-1-0.def",
-		"api-ms-win-crt-heap-l1-1-0.def",
-		"api-ms-win-crt-locale-l1-1-0.def",
-		"api-ms-win-crt-math-l1-1-0.def.in",
-		"api-ms-win-crt-multibyte-l1-1-0.def",
-		"api-ms-win-crt-private-l1-1-0.def.in",
-		"api-ms-win-crt-process-l1-1-0.def",
-		"api-ms-win-crt-runtime-l1-1-0.def.in",
-		"api-ms-win-crt-stdio-l1-1-0.def",
-		"api-ms-win-crt-string-l1-1-0.def",
-		"api-ms-win-crt-time-l1-1-0.def",
-		"api-ms-win-crt-utility-l1-1-0.def",
-	} {
-		outpath := filepath.Join(tmpdir, filepath.Base(name)+".lib")
-		inpath := filepath.Join(root, "lib/mingw-w64/mingw-w64-crt/lib-common/"+name)
-		job := &compileJob{
-			description: "create lib file " + inpath,
-			result:      outpath,
-			run: func(job *compileJob) error {
-				defpath := inpath
-				if strings.HasSuffix(inpath, ".in") {
-					// .in files need to be preprocessed by a preprocessor (-E)
-					// first.
-					defpath = outpath + ".def"
-					err := runCCompiler("-E", "-x", "c", "-Wp,-w", "-P", "-DDEF_X64", "-o", defpath, inpath, "-I"+goenv.Get("TINYGOROOT")+"/lib/mingw-w64/mingw-w64-crt/def-include/")
-					if err != nil {
-						return err
-					}
-				}
-				return link("ld.lld", "-m", "i386pep", "-o", outpath, defpath)
-			},
-		}
-		jobs = append(jobs, job)
-	}
-	return jobs
-}
@@ -1,163 +0,0 @@
-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",
-			"-fno-stack-protector",
-		}
-	},
-	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
-}
@@ -1,27 +0,0 @@
-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
-}
@@ -4,15 +4,12 @@ import (
 	"debug/elf"
 	"io/ioutil"
 	"os"
+	"path/filepath"
 	"sort"

 	"github.com/marcinbor85/gohex"
 )

-// maxPadBytes is the maximum allowed bytes to be padded in a rom extraction
-// this value is currently defined by Nintendo Switch Page Alignment (4096 bytes)
-const maxPadBytes = 4095
-
 // objcopyError is an error returned by functions that act like objcopy.
 type objcopyError struct {
 	Op  string
@@ -61,7 +58,7 @@ func extractROM(path string) (uint64, []byte, error) {

 	progs := make(progSlice, 0, 2)
 	for _, prog := range f.Progs {
-		if prog.Type != elf.PT_LOAD || prog.Filesz == 0 || prog.Off == 0 {
+		if prog.Type != elf.PT_LOAD || prog.Filesz == 0 {
 			continue
 		}
 		progs = append(progs, prog)
@@ -73,19 +70,8 @@ func extractROM(path string) (uint64, []byte, error) {

 	var rom []byte
 	for _, prog := range progs {
-		romEnd := progs[0].Paddr + uint64(len(rom))
-		if prog.Paddr > romEnd && prog.Paddr < romEnd+16 {
-			// Sometimes, the linker seems to insert a bit of padding between
-			// segments. Simply zero-fill these parts.
-			rom = append(rom, make([]byte, prog.Paddr-romEnd)...)
-		}
 		if prog.Paddr != progs[0].Paddr+uint64(len(rom)) {
-			diff := prog.Paddr - (progs[0].Paddr + uint64(len(rom)))
-			if diff > maxPadBytes {
-				return 0, nil, objcopyError{"ROM segments are non-contiguous: " + path, nil}
-			}
-			// Pad the difference
-			rom = append(rom, make([]byte, diff)...)
+			return 0, nil, objcopyError{"ROM segments are non-contiguous: " + path, nil}
 		}
 		data, err := ioutil.ReadAll(prog.Open())
 		if err != nil {
@@ -107,7 +93,7 @@ func extractROM(path string) (uint64, []byte, error) {

 // objcopy converts an ELF file to a different (simpler) output file format:
 // .bin or .hex. It extracts only the .text section.
-func objcopy(infile, outfile, binaryFormat string) error {
+func objcopy(infile, outfile string) error {
 	f, err := os.OpenFile(outfile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
 	if err != nil {
 		return err
@@ -121,20 +107,24 @@ func objcopy(infile, outfile, binaryFormat string) error {
 	}

 	// Write to the file, in the correct format.
-	switch binaryFormat {
-	case "hex":
-		// Intel hex file, includes the firmware start address.
+	switch filepath.Ext(outfile) {
+	case ".gba":
+		// The address is not stored in a .gba file.
+		_, err := f.Write(data)
+		return err
+	case ".bin":
+		// The address is not stored in a .bin file (therefore you
+		// should use .hex files in most cases).
+		_, err := f.Write(data)
+		return err
+	case ".hex":
 		mem := gohex.NewMemory()
 		err := mem.AddBinary(uint32(addr), data)
 		if err != nil {
 			return objcopyError{"failed to create .hex file", err}
 		}
-		return mem.DumpIntelHex(f, 16)
-	case "bin":
-		// The start address is not stored in raw firmware files (therefore you
-		// should use .hex files in most cases).
-		_, err := f.Write(data)
-		return err
+		mem.DumpIntelHex(f, 16) // TODO: handle error
+		return nil
 	default:
 		panic("unreachable")
 	}
@@ -1,7 +1,6 @@
 package builder

 import (
-	"os"
 	"path/filepath"

 	"github.com/tinygo-org/tinygo/goenv"
@@ -11,134 +10,17 @@ import (
 // based on newlib.
 var Picolibc = Library{
 	name: "picolibc",
-	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 {
+	cflags: func() []string {
 		picolibcDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib/libc")
-		return []string{
-			"-Werror",
-			"-Wall",
-			"-std=gnu11",
-			"-D_COMPILING_NEWLIB",
-			"-DHAVE_ALIAS_ATTRIBUTE",
-			"-DTINY_STDIO",
-			"-nostdlibinc",
-			"-isystem", picolibcDir + "/include",
-			"-I" + picolibcDir + "/tinystdio",
-			"-I" + headerPath,
-		}
+		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"}
 	},
 	sourceDir: "lib/picolibc/newlib/libc",
-	librarySources: func(target string) []string {
+	sources: 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",
@@ -1,31 +1,16 @@
 package builder

 import (
-	"bytes"
-	"debug/dwarf"
 	"debug/elf"
-	"debug/pe"
-	"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
+	Packages map[string]*packageSize
+	Sum      *packageSize
 	Code     uint64
-	ROData   uint64
 	Data     uint64
 	BSS      uint64
 }
@@ -41,16 +26,6 @@ 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 {
@@ -70,607 +45,129 @@ func (ps *packageSize) RAM() uint64 {
 	return ps.Data + ps.BSS
 }

-// 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
+type symbolList []elf.Symbol
+
+func (l symbolList) Len() int {
+	return len(l)
 }

-// 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
-)
-
-func (t memoryType) String() string {
-	return [...]string{
-		0:            "-",
-		memoryCode:   "code",
-		memoryData:   "data",
-		memoryROData: "rodata",
-		memoryBSS:    "bss",
-		memoryStack:  "stack",
-	}[t]
-}
-
-// 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()
-		}
+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
 	}
-	return addresses, nil
+	return l[i].Value < l[j].Value
+}
+
+func (l symbolList) Swap(i, j int) {
+	l[i], l[j] = l[j], l[i]
 }

 // loadProgramSize calculate a program/data size breakdown of each package for a
 // given ELF file.
-// 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)
+func loadProgramSize(path string) (*programSize, error) {
+	file, err := elf.Open(path)
 	if err != nil {
 		return nil, err
 	}
-	defer f.Close()
+	defer file.Close()

-	// This stores all chunks of addresses found in the binary.
-	var addresses []addressLine
-
-	// 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
-			}
+	var sumCode uint64
+	var sumData uint64
+	var sumBSS uint64
+	for _, section := range file.Sections {
+		if section.Flags&elf.SHF_ALLOC == 0 {
+			continue
 		}
-
-		// 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
+		if section.Type != elf.SHT_PROGBITS && section.Type != elf.SHT_NOBITS {
+			continue
 		}
-		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.SHN_LORESERVE {
-				// Not a regular section, so skip it.
-				// One example is elf.SHN_ABS, which is used for symbols
-				// declared with an absolute value such as the memset function
-				// on the ESP32 which is defined in the mask ROM.
-				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,
-				})
-			}
+		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
 		}
+	}

-		// 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,
-					})
+	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 {
-					// Regular .bss section.
-					sections = append(sections, memorySection{
-						Address: section.Addr,
-						Size:    section.Size,
-						Type:    memoryBSS,
-					})
+					pkgSize.Data += symbol.Size
 				}
-			} 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 {
+				pkgSize.ROData += symbol.Size
 			}
 		}
-	} else if file, err := pe.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
-			}
-		}
-
-		// Read COFF sections.
-		optionalHeader := file.OptionalHeader.(*pe.OptionalHeader64)
-		for _, section := range file.Sections {
-			// For more information:
-			// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-image_section_header
-			const (
-				IMAGE_SCN_CNT_CODE             = 0x00000020
-				IMAGE_SCN_CNT_INITIALIZED_DATA = 0x00000040
-				IMAGE_SCN_MEM_DISCARDABLE      = 0x02000000
-				IMAGE_SCN_MEM_READ             = 0x40000000
-				IMAGE_SCN_MEM_WRITE            = 0x80000000
-			)
-			if section.Characteristics&IMAGE_SCN_MEM_DISCARDABLE != 0 {
-				// Debug sections, etc.
-				continue
-			}
-			address := uint64(section.VirtualAddress) + optionalHeader.ImageBase
-			if section.Characteristics&IMAGE_SCN_CNT_CODE != 0 {
-				// .text
-				sections = append(sections, memorySection{
-					Address: address,
-					Size:    uint64(section.VirtualSize),
-					Type:    memoryCode,
-				})
-			} else if section.Characteristics&IMAGE_SCN_CNT_INITIALIZED_DATA != 0 {
-				if section.Characteristics&IMAGE_SCN_MEM_WRITE != 0 {
-					// .data
-					sections = append(sections, memorySection{
-						Address: address,
-						Size:    uint64(section.Size),
-						Type:    memoryData,
-					})
-					if section.Size < section.VirtualSize {
-						// Equivalent of a .bss section.
-						// Note: because of how the PE/COFF format is
-						// structured, not all zero-initialized data is marked
-						// as such. A portion may be at the end of the .data
-						// section and is thus marked as initialized data.
-						sections = append(sections, memorySection{
-							Address: address + uint64(section.Size),
-							Size:    uint64(section.VirtualSize) - uint64(section.Size),
-							Type:    memoryBSS,
-						})
-					}
-				} else if section.Characteristics&IMAGE_SCN_MEM_READ != 0 {
-					// .rdata, .buildid, .pdata
-					sections = append(sections, memorySection{
-						Address: address,
-						Size:    uint64(section.VirtualSize),
-						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)
+		lastSymbolValue = symbol.Value
 	}

-	// 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,
-	}
+	sum := &packageSize{}
 	for _, pkg := range sizes {
-		program.Code += pkg.Code
-		program.ROData += pkg.ROData
-		program.Data += pkg.Data
-		program.BSS += pkg.BSS
+		sum.Code += pkg.Code
+		sum.ROData += pkg.ROData
+		sum.Data += pkg.Data
+		sum.BSS += pkg.BSS
 	}
-	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
-	if sizesDebug {
-		fmt.Printf("%08x..%08x %5d: %s\n", addr, sectionEnd, section.Size, section.Type)
-	}
-	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 %5d:  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 %5d:  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
+	return &programSize{Packages: sizes, Code: sumCode, Data: sumData, BSS: sumBSS, Sum: sum}, nil
 }
@@ -13,7 +13,6 @@ import (
 #include <stdlib.h>
 bool tinygo_clang_driver(int argc, char **argv);
 bool tinygo_link_elf(int argc, char **argv);
-bool tinygo_link_mingw(int argc, char **argv);
 bool tinygo_link_wasm(int argc, char **argv);
 */
 import "C"
@@ -25,10 +24,6 @@ const hasBuiltinTools = true
 // This version actually runs the tools because TinyGo was compiled while
 // linking statically with LLVM (with the byollvm build tag).
 func RunTool(tool string, args ...string) error {
-	linker := "elf"
-	if tool == "ld.lld" && len(args) >= 2 && args[0] == "-m" && args[1] == "i386pep" {
-		linker = "mingw"
-	}
 	args = append([]string{"tinygo:" + tool}, args...)

 	var cflag *C.char
@@ -46,14 +41,7 @@ func RunTool(tool string, args ...string) error {
 	case "clang":
 		ok = C.tinygo_clang_driver(C.int(len(args)), (**C.char)(buf))
 	case "ld.lld":
-		switch linker {
-		case "elf":
-			ok = C.tinygo_link_elf(C.int(len(args)), (**C.char)(buf))
-		case "mingw":
-			ok = C.tinygo_link_mingw(C.int(len(args)), (**C.char)(buf))
-		default:
-			return errors.New("unknown linker: " + linker)
-		}
+		ok = C.tinygo_link_elf(C.int(len(args)), (**C.char)(buf))
 	case "wasm-ld":
 		ok = C.tinygo_link_wasm(C.int(len(args)), (**C.char)(buf))
 	default:
@@ -9,8 +9,8 @@ import (
 )

 // runCCompiler invokes a C compiler with the given arguments.
-func runCCompiler(flags ...string) error {
-	if hasBuiltinTools {
+func runCCompiler(command string, flags ...string) error {
+	if hasBuiltinTools && command == "clang" {
 		// Compile this with the internal Clang compiler.
 		headerPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
 		if headerPath == "" {
@@ -23,8 +23,17 @@ func runCCompiler(flags ...string) error {
 		return cmd.Run()
 	}

-	// Compile this with an external invocation of the Clang compiler.
-	return execCommand("clang", flags...)
+	// 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()
 }

 // link invokes a linker with the given name and flags.
@@ -38,8 +47,8 @@ func link(linker string, flags ...string) error {
 	}

 	// Fall back to external command.
-	if _, ok := commands[linker]; ok {
-		return execCommand(linker, flags...)
+	if cmdNames, ok := commands[linker]; ok {
+		return execCommand(cmdNames, flags...)
 	}

 	cmd := exec.Command(linker, flags...)
@@ -141,13 +141,11 @@ 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 {
-		// add remaining block (that isn't full sized)
-		output = append(output, input)
+		output = append(output, input[:len(input)])
 	}
 	return output
 }
@@ -14,7 +14,6 @@ package cgo
 import (
 	"fmt"
 	"go/ast"
-	"go/parser"
 	"go/scanner"
 	"go/token"
 	"path/filepath"
@@ -31,8 +30,7 @@ type cgoPackage struct {
 	generated       *ast.File
 	generatedPos    token.Pos
 	errors          []error
-	currentDir      string // current working directory
-	packageDir      string // full path to the package to process
+	dir             string
 	fset            *token.FileSet
 	tokenFiles      map[string]*token.File
 	missingSymbols  map[string]struct{}
@@ -43,9 +41,6 @@ type cgoPackage struct {
 	elaboratedTypes map[string]*elaboratedTypeInfo
 	enums           map[string]enumInfo
 	anonStructNum   int
-	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
@@ -58,10 +53,9 @@ 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
-	variadic bool
+	args    []paramInfo
+	results *ast.FieldList
+	pos     token.Pos
 }

 // paramInfo is a parameter of a CGo function (see functionInfo).
@@ -126,17 +120,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":      {},
-	"schar":     {},
-	"uchar":     {},
-	"short":     {},
-	"ushort":    {},
-	"int":       {},
-	"uint":      {},
-	"long":      {},
-	"ulong":     {},
-	"longlong":  {},
-	"ulonglong": {},
+	"char":      struct{}{},
+	"schar":     struct{}{},
+	"uchar":     struct{}{},
+	"short":     struct{}{},
+	"ushort":    struct{}{},
+	"int":       struct{}{},
+	"uint":      struct{}{},
+	"long":      struct{}{},
+	"ulong":     struct{}{},
+	"longlong":  struct{}{},
+	"ulonglong": struct{}{},
 }

 // cgoTypes lists some C types with ambiguous sizes that must be retrieved
@@ -157,49 +151,14 @@ typedef long long           _Cgo_longlong;
 typedef unsigned long long  _Cgo_ulonglong;
 `

-// First part of the generated Go file. Written here as Go because that's much
-// easier than constructing the entire AST in memory.
-// The string/bytes functions below implement C.CString etc. To make sure the
-// runtime doesn't need to know the C int type, lengths are converted to uintptr
-// first.
-// These functions will be modified to get a "C." prefix, so the source below
-// doesn't reflect the final AST.
-const generatedGoFilePrefix = `
-import "unsafe"
-
-var _ unsafe.Pointer
-
-//go:linkname C.CString runtime.cgo_CString
-func CString(string) *C.char
-
-//go:linkname C.GoString runtime.cgo_GoString
-func GoString(*C.char) string
-
-//go:linkname C.__GoStringN runtime.cgo_GoStringN
-func __GoStringN(*C.char, uintptr) string
-
-func GoStringN(cstr *C.char, length C.int) string {
-	return C.__GoStringN(cstr, uintptr(length))
-}
-
-//go:linkname C.__GoBytes runtime.cgo_GoBytes
-func __GoBytes(unsafe.Pointer, uintptr) []byte
-
-func GoBytes(ptr unsafe.Pointer, length C.int) []byte {
-	return C.__GoBytes(ptr, uintptr(length))
-}
-`
-
 // 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, 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) {
+// files. If there is one or more error, it returns these in the []error slice
+// but still modifies the AST.
+func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string) (*ast.File, []error) {
 	p := &cgoPackage{
-		currentDir:      dir,
+		dir:             dir,
 		fset:            fset,
 		tokenFiles:      map[string]*token.File{},
 		missingSymbols:  map[string]struct{}{},
@@ -209,9 +168,13 @@ 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})
@@ -220,41 +183,68 @@ 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, nil, nil, nil, []error{
+		return nil, []error{
 			scanner.Error{
 				Pos: fset.Position(files[0].Pos()),
 				Msg: "cgo: cannot find absolute path: " + err.Error(), // TODO: wrap this error
 			},
 		}
 	}
-	p.packageDir = filepath.Dir(packagePath)
+	packagePath = filepath.Dir(packagePath)

 	// Construct a new in-memory AST for CGo declarations of this package.
-	// The first part is written as Go code that is then parsed, but more code
-	// is added later to the AST to declare functions, globals, etc.
-	goCode := "package " + files[0].Name.Name + "\n\n" + generatedGoFilePrefix
-	p.generated, err = parser.ParseFile(fset, dir+"/!cgo.go", goCode, parser.ParseComments)
-	if err != nil {
-		// This is always a bug in the cgo package.
-		panic("unexpected error: " + err.Error())
+	unsafeImport := &ast.ImportSpec{
+		Path: &ast.BasicLit{
+			ValuePos: p.generatedPos,
+			Kind:     token.STRING,
+			Value:    "\"unsafe\"",
+		},
+		EndPos: p.generatedPos,
 	}
-	// If the Comments field is not set to nil, the fmt package will get
-	// confused about where comments should go.
-	p.generated.Comments = nil
-	// Adjust some of the functions in there.
-	for _, decl := range p.generated.Decls {
-		switch decl := decl.(type) {
-		case *ast.FuncDecl:
-			switch decl.Name.Name {
-			case "CString", "GoString", "GoStringN", "__GoStringN", "GoBytes", "__GoBytes":
-				// Adjust the name to have a "C." prefix so it is correctly
-				// resolved.
-				decl.Name.Name = "C." + decl.Name.Name
-			}
-		}
+	p.generated = &ast.File{
+		Package: p.generatedPos,
+		Name: &ast.Ident{
+			NamePos: p.generatedPos,
+			Name:    files[0].Name.Name,
+		},
+		Decls: []ast.Decl{
+			// import "unsafe"
+			&ast.GenDecl{
+				TokPos: p.generatedPos,
+				Tok:    token.IMPORT,
+				Specs: []ast.Spec{
+					unsafeImport,
+				},
+			},
+			// var _ unsafe.Pointer
+			// This avoids type errors when the unsafe package is never used.
+			&ast.GenDecl{
+				Tok: token.VAR,
+				Specs: []ast.Spec{
+					&ast.ValueSpec{
+						Names: []*ast.Ident{
+							&ast.Ident{
+								Name: "_",
+								Obj: &ast.Object{
+									Kind: ast.Var,
+									Name: "_",
+								},
+							},
+						},
+						Type: &ast.SelectorExpr{
+							X: &ast.Ident{
+								Name: "unsafe",
+							},
+							Sel: &ast.Ident{
+								Name: "Pointer",
+							},
+						},
+					},
+				},
+			},
+		},
+		Imports: []*ast.ImportSpec{unsafeImport},
 	}
-	// Patch some types, for example *C.char in C.CString.
-	astutil.Apply(p.generated, p.walker, nil)

 	// Find all C.* symbols.
 	for _, f := range files {
@@ -264,10 +254,9 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 		p.missingSymbols["_Cgo_"+name] = struct{}{}
 	}

-	// 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
+	// Find `import "C"` statements in the file.
+	var statements []*ast.GenDecl
+	for _, f := range files {
 		for i := 0; i < len(f.Decls); i++ {
 			decl := f.Decls[i]
 			genDecl, ok := decl.(*ast.GenDecl)
@@ -291,52 +280,104 @@ 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--
-
-			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
+		// Print the AST, for debugging.
+		//ast.Print(fset, f)
 	}

-	// 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...)
+	// 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!")
+				}

-	// Process CGo imports for each file.
-	for i, f := range files {
-		p.parseFragment(cgoHeaders[i]+cgoTypes, cflagsForCGo, filepath.Base(fset.File(f.Pos()).Name()))
+				// 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...)
+				default:
+					startPos := strings.LastIndex(line[4:colon], name) + 4
+					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+startPos], "invalid #cgo line: "+name)
+					continue
+				}
+			}
+		}
+	}
+
+	// Process all CGo imports.
+	for _, genDecl := range statements {
+		cgoComment := genDecl.Doc.Text()
+
+		pos := genDecl.Pos()
+		if genDecl.Doc != nil {
+			pos = genDecl.Doc.Pos()
+		}
+		position := fset.PositionFor(pos, true)
+		p.parseFragment(cgoComment+cgoTypes, cflags, position.Filename, position.Line)
 	}

 	// Declare functions found by libclang.
@@ -371,18 +412,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, cgoHeaders, p.cflags, p.ldflags, p.visitedFiles, p.errors
+	return p.generated, 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 (p *cgoPackage) makePathsAbsolute(args []string) {
+func makePathsAbsolute(args []string, packagePath string) {
 	nextIsPath := false
 	for i, arg := range args {
 		if nextIsPath {
 			if !filepath.IsAbs(arg) {
-				args[i] = filepath.Join(p.packageDir, arg)
+				args[i] = filepath.Join(packagePath, arg)
 			}
 		}
 		if arg == "-I" || arg == "-L" {
@@ -392,95 +433,12 @@ func (p *cgoPackage) makePathsAbsolute(args []string) {
 		if strings.HasPrefix(arg, "-I") || strings.HasPrefix(arg, "-L") {
 			path := arg[2:]
 			if !filepath.IsAbs(path) {
-				args[i] = arg[:2] + filepath.Join(p.packageDir, path)
+				args[i] = arg[:2] + filepath.Join(packagePath, 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() {
@@ -497,14 +455,6 @@ func (p *cgoPackage) addFuncDecls() {
 		}
 		args := make([]*ast.Field, len(fn.args))
 		decl := &ast.FuncDecl{
-			Doc: &ast.CommentGroup{
-				List: []*ast.Comment{
-					{
-						Slash: fn.pos - 1,
-						Text:  "//export " + name,
-					},
-				},
-			},
 			Name: &ast.Ident{
 				NamePos: fn.pos,
 				Name:    "C." + name,
@@ -520,17 +470,11 @@ func (p *cgoPackage) addFuncDecls() {
 				Results: fn.results,
 			},
 		}
-		if fn.variadic {
-			decl.Doc.List = append(decl.Doc.List, &ast.Comment{
-				Slash: fn.pos - 1,
-				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{
@@ -578,7 +522,7 @@ func (p *cgoPackage) addFuncPtrDecls() {
 			Name: "C." + name + "$funcaddr",
 		}
 		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{{
+			Names: []*ast.Ident{&ast.Ident{
 				NamePos: fn.pos,
 				Name:    "C." + name + "$funcaddr",
 				Obj:     obj,
@@ -628,7 +572,7 @@ func (p *cgoPackage) addConstDecls() {
 			Name: "C." + name,
 		}
 		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{{
+			Names: []*ast.Ident{&ast.Ident{
 				NamePos: constVal.pos,
 				Name:    "C." + name,
 				Obj:     obj,
@@ -657,27 +601,19 @@ func (p *cgoPackage) addVarDecls() {
 	}
 	sort.Strings(names)
 	for _, name := range names {
-		global := p.globals[name]
 		gen := &ast.GenDecl{
-			TokPos: global.pos,
+			TokPos: token.NoPos,
 			Tok:    token.VAR,
 			Lparen: token.NoPos,
 			Rparen: token.NoPos,
-			Doc: &ast.CommentGroup{
-				List: []*ast.Comment{
-					{
-						Slash: global.pos - 1,
-						Text:  "//go:extern " + name,
-					},
-				},
-			},
 		}
+		global := p.globals[name]
 		obj := &ast.Object{
 			Kind: ast.Var,
 			Name: "C." + name,
 		}
 		valueSpec := &ast.ValueSpec{
-			Names: []*ast.Ident{{
+			Names: []*ast.Ident{&ast.Ident{
 				NamePos: global.pos,
 				Name:    "C." + name,
 				Obj:     obj,
@@ -878,9 +814,9 @@ func (p *cgoPackage) makeUnionField(typ *elaboratedTypeInfo) *ast.StructType {
 		Struct: typ.typeExpr.Struct,
 		Fields: &ast.FieldList{
 			Opening: typ.typeExpr.Fields.Opening,
-			List: []*ast.Field{{
+			List: []*ast.Field{&ast.Field{
 				Names: []*ast.Ident{
-					{
+					&ast.Ident{
 						NamePos: typ.typeExpr.Fields.Opening,
 						Name:    "$union",
 					},
@@ -961,9 +897,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",
 						},
@@ -992,7 +928,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,
@@ -1071,9 +1007,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{
@@ -1107,7 +1043,7 @@ func (p *cgoPackage) createBitfieldGetter(bitfield bitfieldInfo, typeName string
 			},
 			Results: &ast.FieldList{
 				List: []*ast.Field{
-					{
+					&ast.Field{
 						Type: bitfield.field.Type,
 					},
 				},
@@ -1224,9 +1160,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{
@@ -1257,9 +1193,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,
@@ -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,37 +23,24 @@ 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.ReplaceAll(result, "\r\n", "\n")
+	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}")
+
 	return actual
 }

 func TestCGo(t *testing.T) {
-	var cflags = []string{"--target=armv6m-unknown-unknown-eabi"}
+	var cflags = []string{"--target=armv6m-none-eabi"}

-	for _, name := range []string{
-		"basic",
-		"errors",
-		"types",
-		"symbols",
-		"flags",
-		"const",
-	} {
+	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()
@@ -63,7 +50,7 @@ func TestCGo(t *testing.T) {
 			}

 			// Process the AST with CGo.
-			cgoAST, _, _, _, _, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)
+			cgoAST, cgoErrors := Process([]*ast.File{f}, "testdata", fset, cflags)

 			// Check the AST for type errors.
 			var typecheckErrors []error
@@ -103,7 +90,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Errorf("could not write out CGo AST: %v", err)
 			}
-			actual := normalizeResult(buf.String())
+			actual := normalizeResult(string(buf.Bytes()))

 			// Read the file with the expected output, to compare against.
 			outfile := filepath.Join("testdata", name+".out.go")
@@ -111,7 +98,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Fatalf("could not read expected output: %v", err)
 			}
-			expected := strings.ReplaceAll(string(expectedBytes), "\r\n", "\n")
+			expected := strings.Replace(string(expectedBytes), "\r\n", "\n", -1)

 			// Check whether the output is as expected.
 			if expected != actual {
@@ -152,7 +139,7 @@ func formatDiagnostic(err error) string {
 	msg := err.Error()
 	if runtime.GOOS == "windows" {
 		// Fix Windows path slashes.
-		msg = strings.ReplaceAll(msg, "testdata\\", "testdata/")
+		msg = strings.Replace(msg, "testdata\\", "testdata/", -1)
 	}
 	return "//     " + msg + "\n"
 }
@@ -11,184 +11,105 @@ 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, precedenceLowest)
-	t.Next()
-	if t.curToken != token.EOF {
+	expr, err := parseConstExpr(t)
+	if t.token != token.EOF {
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.curPos),
-			Msg: "unexpected token " + t.curToken.String() + ", expected end of expression",
+			Pos: t.fset.Position(t.pos),
+			Msg: "unexpected token " + t.token.String(),
 		}
 	}
 	return expr, err
 }

 // parseConstExpr parses a stream of C tokens to a Go expression.
-func parseConstExpr(t *tokenizer, precedence int) (ast.Expr, *scanner.Error) {
-	if t.curToken == token.EOF {
+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:
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.curPos),
+			Pos: t.fset.Position(t.pos),
 			Msg: "empty constant",
 		}
-	}
-	prefix := prefixParseFns[t.curToken]
-	if prefix == nil {
+	default:
 		return nil, &scanner.Error{
-			Pos: t.fset.Position(t.curPos),
-			Msg: fmt.Sprintf("unexpected token %s", t.curToken),
+			Pos: t.fset.Position(t.pos),
+			Msg: fmt.Sprintf("unexpected token %s", t.token),
 		}
 	}
-	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.curPos),
-		Msg: fmt.Sprintf("unexpected token %s, expected %s", t.curToken, expected),
+		Pos: t.fset.Position(t.pos),
+		Msg: fmt.Sprintf("unexpected token %s, expected %s", t.token, expected),
 	}
 }

 // tokenizer reads C source code and converts it to Go tokens.
 type tokenizer struct {
-	curPos, peekPos     token.Pos
-	fset                *token.FileSet
-	curToken, peekToken token.Token
-	curValue, peekValue string
-	buf                 string
+	pos   token.Pos
+	fset  *token.FileSet
+	token token.Token
+	value 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{
-		peekPos:   start,
-		fset:      fset,
-		buf:       buf,
-		peekToken: token.ILLEGAL,
+		pos:   start,
+		fset:  fset,
+		buf:   buf,
+		token: token.ILLEGAL,
 	}
-	// Parse the first two tokens (cur and peek).
-	t.Next()
-	t.Next()
+	t.Next() // Parse the first token.
 	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() {
-	// 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))
+	t.pos += token.Pos(len(t.value))
 	for {
 		if len(t.buf) == 0 {
-			t.peekToken = token.EOF
+			t.token = token.EOF
 			return
 		}
 		c := t.buf[0]
@@ -197,28 +118,17 @@ 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.peekPos++
+			t.pos++
 			t.buf = t.buf[1:]
-		case c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/' || c == '%':
+		case c == '(' || c == ')':
 			// Single-character tokens.
-			// TODO: ++ (increment) and -- (decrement) operators.
 			switch c {
 			case '(':
-				t.peekToken = token.LPAREN
+				t.token = token.LPAREN
 			case ')':
-				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.token = token.RPAREN
 			}
-			t.peekValue = t.buf[:1]
+			t.value = t.buf[:1]
 			t.buf = t.buf[1:]
 			return
 		case c >= '0' && c <= '9':
@@ -236,17 +146,17 @@ func (t *tokenizer) Next() {
 					break
 				}
 			}
-			t.peekValue = t.buf[:tokenLen]
+			t.value = 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.peekToken = token.FLOAT
-				t.peekValue = strings.TrimRight(t.peekValue, "f")
+				t.token = token.FLOAT
+				t.value = strings.TrimRight(t.value, "f")
 			} else {
-				t.peekToken = token.INT
-				t.peekValue = strings.TrimRight(t.peekValue, "uUlL")
+				t.token = token.INT
+				t.value = strings.TrimRight(t.value, "uUlL")
 			}
 			return
 		case c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c == '_':
@@ -260,9 +170,9 @@ func (t *tokenizer) Next() {
 					break
 				}
 			}
-			t.peekValue = t.buf[:tokenLen]
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
-			t.peekToken = token.IDENT
+			t.token = token.IDENT
 			return
 		case c == '"':
 			// String constant. Find the first '"' character that is not
@@ -278,8 +188,8 @@ func (t *tokenizer) Next() {
 					escape = c == '\\'
 				}
 			}
-			t.peekToken = token.STRING
-			t.peekValue = t.buf[:tokenLen]
+			t.token = token.STRING
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			return
 		case c == '\'':
@@ -296,12 +206,12 @@ func (t *tokenizer) Next() {
 					escape = c == '\\'
 				}
 			}
-			t.peekToken = token.CHAR
-			t.peekValue = t.buf[:tokenLen]
+			t.token = token.CHAR
+			t.value = t.buf[:tokenLen]
 			t.buf = t.buf[tokenLen:]
 			return
 		default:
-			t.peekToken = token.ILLEGAL
+			t.token = token.ILLEGAL
 			return
 		}
 	}
@@ -18,7 +18,7 @@ func TestParseConst(t *testing.T) {
 		{`(5)`, `(5)`},
 		{`(((5)))`, `(5)`},
 		{`)`, `error: 1:1: unexpected token )`},
-		{`5)`, `error: 1:2: unexpected token ), expected end of expression`},
+		{`5)`, `error: 1:2: unexpected token )`},
 		{"  \t)", `error: 1:4: unexpected token )`},
 		{`5.8f`, `5.8`},
 		{`foo`, `C.foo`},
@@ -30,24 +30,7 @@ func TestParseConst(t *testing.T) {
 		{`'a'`, `'a'`},
 		{`0b10`, `0b10`},
 		{`0x1234_5678`, `0x1234_5678`},
-		{`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`},
+		{`5 5`, `error: 1:3: unexpected token INT`}, // test for a bugfix
 	} {
 		fset := token.NewFileSet()
 		startPos := fset.AddFile("", -1, 1000).Pos(0)
@@ -4,7 +4,6 @@ package cgo
 // modification. It does not touch the AST itself.

 import (
-	"crypto/sha512"
 	"fmt"
 	"go/ast"
 	"go/scanner"
@@ -16,7 +15,7 @@ import (
 )

 /*
-#include <clang-c/Index.h> // if this fails, install libclang-11-dev
+#include <clang-c/Index.h> // if this fails, install libclang-10-dev
 #include <stdlib.h>
 #include <stdint.h>

@@ -57,7 +56,6 @@ 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"

@@ -72,14 +70,17 @@ var diagnosticSeverity = [...]string{
 	C.CXDiagnostic_Fatal:   "fatal",
 }

-func (p *cgoPackage) parseFragment(fragment string, cflags []string, filename string) {
+func (p *cgoPackage) parseFragment(fragment string, cflags []string, posFilename string, posLine int) {
 	index := C.clang_createIndex(0, 0)
 	defer C.clang_disposeIndex(index)

 	// pretend to be a .c file
-	filenameC := C.CString(filename + "!cgo.c")
+	filenameC := C.CString(posFilename + "!cgo.c")
 	defer C.free(unsafe.Pointer(filenameC))

+	// fix up error locations
+	fragment = fmt.Sprintf("# %d %#v\n", posLine+1, posFilename) + fragment
+
 	fragmentC := C.CString(fragment)
 	defer C.free(unsafe.Pointer(fragmentC))

@@ -113,7 +114,6 @@ func (p *cgoPackage) parseFragment(fragment string, cflags []string, filename st
 	}
 	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,36 +134,10 @@ func (p *cgoPackage) parseFragment(fragment string, cflags []string, filename st
 		}
 	}

-	// 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
@@ -178,10 +152,12 @@ 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,
-			variadic: C.clang_isFunctionTypeVariadic(cursorType) != 0,
+			pos: pos,
 		}
 		p.functions[name] = fn
 		for i := 0; i < numArgs; i++ {
@@ -193,14 +169,14 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 			}
 			fn.args = append(fn.args, paramInfo{
 				name:     argName,
-				typeExpr: p.makeDecayingASTType(argType, pos),
+				typeExpr: p.makeASTType(argType, pos),
 			})
 		}
 		resultType := C.tinygo_clang_getCursorResultType(c)
 		if resultType.kind != C.CXType_Void {
 			fn.results = &ast.FieldList{
 				List: []*ast.Field{
-					{
+					&ast.Field{
 						Type: p.makeASTType(resultType, pos),
 					},
 				},
@@ -270,9 +246,9 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 		}
 		value := source[len(name):]
 		// Try to convert this #define into a Go constant expression.
-		expr, scannerError := parseConst(pos+token.Pos(len(name)), p.fset, value)
-		if scannerError != nil {
-			p.errors = append(p.errors, *scannerError)
+		expr, err := parseConst(pos+token.Pos(len(name)), p.fset, value)
+		if err != nil {
+			p.errors = append(p.errors, err)
 		}
 		if expr != nil {
 			// Parsing was successful.
@@ -377,7 +353,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.currentDir, position.Filename)
+		relpath, err := filepath.Rel(p.dir, position.Filename)
 		if err == nil {
 			position.Filename = relpath
 		}
@@ -388,41 +364,6 @@ 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 {
@@ -807,7 +748,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{
@@ -828,18 +769,8 @@ 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{
-			ValuePos: pos,
-			Kind:     token.INT,
-			Value:    strconv.FormatInt(int64(value), 10),
-		},
-		pos: pos,
+		expr: &ast.BasicLit{pos, token.INT, 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)
-}
@@ -0,0 +1,14 @@
+// +build !byollvm
+// +build !llvm9
+
+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
+*/
+import "C"
@@ -1,16 +0,0 @@
-//go:build !byollvm && llvm11
-// +build !byollvm,llvm11
-
-package cgo
-
-/*
-#cgo linux        CFLAGS:  -I/usr/lib/llvm-11/include
-#cgo darwin amd64 CFLAGS:  -I/usr/local/opt/llvm@11/include
-#cgo darwin arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@11/include
-#cgo freebsd      CFLAGS:  -I/usr/local/llvm11/include
-#cgo linux        LDFLAGS: -L/usr/lib/llvm-11/lib -lclang
-#cgo darwin amd64 LDFLAGS: -L/usr/local/opt/llvm@11/lib -lclang -lffi
-#cgo darwin arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@11/lib -lclang -lffi
-#cgo freebsd      LDFLAGS: -L/usr/local/llvm11/lib -lclang
-*/
-import "C"
@@ -1,16 +0,0 @@
-//go:build !byollvm && llvm12
-// +build !byollvm,llvm12
-
-package cgo
-
-/*
-#cgo linux        CFLAGS:  -I/usr/lib/llvm-12/include
-#cgo darwin amd64 CFLAGS:  -I/usr/local/opt/llvm@12/include
-#cgo darwin arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@12/include
-#cgo freebsd      CFLAGS:  -I/usr/local/llvm12/include
-#cgo linux        LDFLAGS: -L/usr/lib/llvm-12/lib -lclang
-#cgo darwin amd64 LDFLAGS: -L/usr/local/opt/llvm@12/lib -lclang -lffi
-#cgo darwin arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@12/lib -lclang -lffi
-#cgo freebsd      LDFLAGS: -L/usr/local/llvm12/lib -lclang
-*/
-import "C"
@@ -1,16 +0,0 @@
-//go:build !byollvm && !llvm11 && !llvm12
-// +build !byollvm,!llvm11,!llvm12
-
-package cgo
-
-/*
-#cgo linux        CFLAGS:  -I/usr/lib/llvm-13/include
-#cgo darwin amd64 CFLAGS:  -I/usr/local/opt/llvm@13/include
-#cgo darwin arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@13/include
-#cgo freebsd      CFLAGS:  -I/usr/local/llvm13/include
-#cgo linux        LDFLAGS: -L/usr/lib/llvm-13/lib -lclang
-#cgo darwin amd64 LDFLAGS: -L/usr/local/opt/llvm@13/lib -lclang -lffi
-#cgo darwin arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@13/lib -lclang -lffi
-#cgo freebsd      LDFLAGS: -L/usr/local/llvm13/lib -lclang
-*/
-import "C"
@@ -0,0 +1,14 @@
+// +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"
@@ -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-11-dev
+#include <clang-c/Index.h> // if this fails, install libclang-10-dev

 CXCursor tinygo_clang_getTranslationUnitCursor(CXTranslationUnit tu) {
 	return clang_getTranslationUnitCursor(tu);
@@ -4,26 +4,6 @@ import "unsafe"

 var _ unsafe.Pointer

-//go:linkname C.CString runtime.cgo_CString
-func C.CString(string) *C.char
-
-//go:linkname C.GoString runtime.cgo_GoString
-func C.GoString(*C.char) string
-
-//go:linkname C.__GoStringN runtime.cgo_GoStringN
-func C.__GoStringN(*C.char, uintptr) string
-
-func C.GoStringN(cstr *C.char, length C.int) string {
-	return C.__GoStringN(cstr, uintptr(length))
-}
-
-//go:linkname C.__GoBytes runtime.cgo_GoBytes
-func C.__GoBytes(unsafe.Pointer, uintptr) []byte
-
-func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
-	return C.__GoBytes(ptr, uintptr(length))
-}
-
 type C.int16_t = int16
 type C.int32_t = int32
 type C.int64_t = int64
@@ -4,26 +4,6 @@ import "unsafe"

 var _ unsafe.Pointer

-//go:linkname C.CString runtime.cgo_CString
-func C.CString(string) *C.char
-
-//go:linkname C.GoString runtime.cgo_GoString
-func C.GoString(*C.char) string
-
-//go:linkname C.__GoStringN runtime.cgo_GoStringN
-func C.__GoStringN(*C.char, uintptr) string
-
-func C.GoStringN(cstr *C.char, length C.int) string {
-	return C.__GoStringN(cstr, uintptr(length))
-}
-
-//go:linkname C.__GoBytes runtime.cgo_GoBytes
-func C.__GoBytes(unsafe.Pointer, uintptr) []byte
-
-func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
-	return C.__GoBytes(ptr, uintptr(length))
-}
-
 const C.bar = C.foo
 const C.foo = 3

@@ -14,12 +14,6 @@ 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
@@ -36,6 +30,4 @@ var (
 	_ = C.SOME_CONST_1

 	_ byte = C.SOME_CONST_3
-
-	_ = C.SOME_CONST_4
 )
@@ -1,16 +1,13 @@
 // CGo errors:
 //     testdata/errors.go:4:2: warning: some warning
 //     testdata/errors.go:11:9: error: unknown type name 'someType'
-//     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
+//     testdata/errors.go:13:23: unexpected token )

 // Type checking errors after CGo processing:
-//     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as uint8 value in variable declaration (overflows)
+//     testdata/errors.go:102: 2 << 10 (untyped int constant 2048) overflows uint8
 //     testdata/errors.go:105: unknown field z in struct literal
 //     testdata/errors.go:108: undeclared name: C.SOME_CONST_1
-//     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
+//     testdata/errors.go:110: C.SOME_CONST_3 (untyped int constant 1234) overflows byte

 package main

@@ -18,26 +15,6 @@ import "unsafe"

 var _ unsafe.Pointer

-//go:linkname C.CString runtime.cgo_CString
-func C.CString(string) *C.char
-
-//go:linkname C.GoString runtime.cgo_GoString
-func C.GoString(*C.char) string
-
-//go:linkname C.__GoStringN runtime.cgo_GoStringN
-func C.__GoStringN(*C.char, uintptr) string
-
-func C.GoStringN(cstr *C.char, length C.int) string {
-	return C.__GoStringN(cstr, uintptr(length))
-}
-
-//go:linkname C.__GoBytes runtime.cgo_GoBytes
-func C.__GoBytes(unsafe.Pointer, uintptr) []byte
-
-func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
-	return C.__GoBytes(ptr, uintptr(length))
-}
-
 const C.SOME_CONST_3 = 1234

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

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

 package main

@@ -9,26 +8,6 @@ import "unsafe"

 var _ unsafe.Pointer

-//go:linkname C.CString runtime.cgo_CString
-func C.CString(string) *C.char
-
-//go:linkname C.GoString runtime.cgo_GoString
-func C.GoString(*C.char) string
-
-//go:linkname C.__GoStringN runtime.cgo_GoStringN
-func C.__GoStringN(*C.char, uintptr) string
-
-func C.GoStringN(cstr *C.char, length C.int) string {
-	return C.__GoStringN(cstr, uintptr(length))
-}
-
-//go:linkname C.__GoBytes runtime.cgo_GoBytes
-func C.__GoBytes(unsafe.Pointer, uintptr) []byte
-
-func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
-	return C.__GoBytes(ptr, uintptr(length))
-}
-
 const C.BAR = 3
 const C.FOO_H = 1

@@ -1,23 +0,0 @@
-package main
-
-/*
-// Function signatures.
-int foo(int a, int b);
-void variadic0();
-void variadic2(int x, int y, ...);
-
-// Global variable signatures.
-extern int someValue;
-*/
-import "C"
-
-// Test function signatures.
-func accessFunctions() {
-	C.foo(3, 4)
-	C.variadic0()
-	C.variadic2(3, 5)
-}
-
-func accessGlobals() {
-	_ = C.someValue
-}
@@ -1,64 +0,0 @@
-package main
-
-import "unsafe"
-
-var _ unsafe.Pointer
-
-//go:linkname C.CString runtime.cgo_CString
-func C.CString(string) *C.char
-
-//go:linkname C.GoString runtime.cgo_GoString
-func C.GoString(*C.char) string
-
-//go:linkname C.__GoStringN runtime.cgo_GoStringN
-func C.__GoStringN(*C.char, uintptr) string
-
-func C.GoStringN(cstr *C.char, length C.int) string {
-	return C.__GoStringN(cstr, uintptr(length))
-}
-
-//go:linkname C.__GoBytes runtime.cgo_GoBytes
-func C.__GoBytes(unsafe.Pointer, uintptr) []byte
-
-func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
-	return C.__GoBytes(ptr, uintptr(length))
-}
-
-//export foo
-func C.foo(a C.int, b C.int) C.int
-
-//export variadic0
-//go:variadic
-func C.variadic0()
-
-//export variadic2
-//go:variadic
-func C.variadic2(x C.int, y C.int)
-
-var C.foo$funcaddr unsafe.Pointer
-var C.variadic0$funcaddr unsafe.Pointer
-var C.variadic2$funcaddr unsafe.Pointer
-
-//go:extern someValue
-var C.someValue C.int
-
-type C.int16_t = int16
-type C.int32_t = int32
-type C.int64_t = int64
-type C.int8_t = int8
-type C.uint16_t = uint16
-type C.uint32_t = uint32
-type C.uint64_t = uint64
-type C.uint8_t = uint8
-type C.uintptr_t = uintptr
-type C.char uint8
-type C.int int32
-type C.long int32
-type C.longlong int64
-type C.schar int8
-type C.short int16
-type C.uchar uint8
-type C.uint uint32
-type C.ulong uint32
-type C.ulonglong uint64
-type C.ushort uint16
@@ -107,10 +107,6 @@ typedef struct {
 */
 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
@@ -4,26 +4,6 @@ import "unsafe"

 var _ unsafe.Pointer

-//go:linkname C.CString runtime.cgo_CString
-func C.CString(string) *C.char
-
-//go:linkname C.GoString runtime.cgo_GoString
-func C.GoString(*C.char) string
-
-//go:linkname C.__GoStringN runtime.cgo_GoStringN
-func C.__GoStringN(*C.char, uintptr) string
-
-func C.GoStringN(cstr *C.char, length C.int) string {
-	return C.__GoStringN(cstr, uintptr(length))
-}
-
-//go:linkname C.__GoBytes runtime.cgo_GoBytes
-func C.__GoBytes(unsafe.Pointer, uintptr) []byte
-
-func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
-	return C.__GoBytes(ptr, uintptr(length))
-}
-
 const C.option2A = 20
 const C.optionA = 0
 const C.optionB = 1
@@ -82,7 +62,9 @@ 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
 }
@@ -118,9 +100,15 @@ 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 }

@@ -145,7 +133,9 @@ 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))
 }
@@ -5,9 +5,9 @@ package compileopts
 import (
 	"errors"
 	"fmt"
-	"os"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"

 	"github.com/tinygo-org/tinygo/goenv"
@@ -22,7 +22,30 @@ type Config struct {
 	TestConfig     TestConfig
 }

-// Triple returns the LLVM target triple, like armv6m-unknown-unknown-eabi.
+// 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.
 func (c *Config) Triple() string {
 	return c.Target.Triple
 }
@@ -34,16 +57,10 @@ func (c *Config) CPU() string {
 }

 // Features returns a list of features this CPU supports. For example, for a
-// RISC-V processor, that could be "+a,+c,+m". For many targets, an empty list
-// will be returned.
-func (c *Config) Features() string {
-	if c.Target.Features == "" {
-		return c.Options.LLVMFeatures
-	}
-	if c.Options.LLVMFeatures == "" {
-		return c.Target.Features
-	}
-	return c.Target.Features + "," + c.Options.LLVMFeatures
+// RISC-V processor, that could be ["+a", "+c", "+m"]. For many targets, an
+// empty list will be returned.
+func (c *Config) Features() []string {
+	return c.Target.Features
 }

 // GOOS returns the GOOS of the target. This might not always be the actual OS:
@@ -60,15 +77,9 @@ func (c *Config) GOARCH() string {
 	return c.Target.GOARCH
 }

-// GOARM will return the GOARM environment variable given to the compiler when
-// building a program.
-func (c *Config) GOARM() string {
-	return c.Options.GOARM
-}
-
 // BuildTags returns the complete list of build tags used during this build.
 func (c *Config) BuildTags() []string {
-	tags := append(c.Target.BuildTags, []string{"tinygo", "math_big_pure_go", "gc." + c.GC(), "scheduler." + c.Scheduler(), "serial." + c.Serial()}...)
+	tags := append(c.Target.BuildTags, []string{"tinygo", "gc." + c.GC(), "scheduler." + c.Scheduler()}...)
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
@@ -85,7 +96,7 @@ func (c *Config) CgoEnabled() bool {
 }

 // GC returns the garbage collection strategy in use on this platform. Valid
-// values are "none", "leaking", and "conservative".
+// values are "none", "leaking", "extalloc", and "conservative".
 func (c *Config) GC() string {
 	if c.Options.GC != "" {
 		return c.Options.GC
@@ -93,28 +104,33 @@ func (c *Config) GC() string {
 	if c.Target.GC != "" {
 		return c.Target.GC
 	}
-	return "conservative"
+	for _, tag := range c.Target.BuildTags {
+		if tag == "baremetal" || tag == "wasm" {
+			return "conservative"
+		}
+	}
+	return "extalloc"
 }

 // NeedsStackObjects returns true if the compiler should insert stack objects
 // that can be traced by the garbage collector.
 func (c *Config) NeedsStackObjects() bool {
 	switch c.GC() {
-	case "conservative":
+	case "conservative", "extalloc":
 		for _, tag := range c.BuildTags() {
-			if tag == "tinygo.wasm" {
-				return true
+			if tag == "baremetal" {
+				return false
 			}
 		}

-		return false
+		return true
 	default:
 		return false
 	}
 }

-// Scheduler returns the scheduler implementation. Valid values are "none",
-// "asyncify" and "tasks".
+// Scheduler returns the scheduler implementation. Valid values are "coroutines"
+// and "tasks".
 func (c *Config) Scheduler() string {
 	if c.Options.Scheduler != "" {
 		return c.Options.Scheduler
@@ -122,40 +138,22 @@ func (c *Config) Scheduler() string {
 	if c.Target.Scheduler != "" {
 		return c.Target.Scheduler
 	}
-	// Fall back to none.
-	return "none"
+	// Fall back to coroutines, which are supported everywhere.
+	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
+// 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.
+	switch c.Scheduler() {
+	case "none", "coroutines":
+		return FuncValueSwitch
+	case "tasks":
+		return FuncValueDoubleword
 	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)
+		panic("unknown scheduler type")
 	}
 }

@@ -166,121 +164,17 @@ func (c *Config) PanicStrategy() string {
 	return c.Options.PanicStrategy
 }

-// AutomaticStackSize returns whether goroutine stack sizes should be determined
-// automatically at compile time, if possible. If it is false, no attempt is
-// made.
-func (c *Config) AutomaticStackSize() bool {
-	if c.Target.AutoStackSize != nil && c.Scheduler() == "tasks" {
-		return *c.Target.AutoStackSize
-	}
-	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) {
-	archname := c.Triple()
-	if c.CPU() != "" {
-		archname += "-" + c.CPU()
-	}
-
-	// Try to load a precompiled library.
-	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", archname, 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.
-	return filepath.Join(goenv.Get("GOCACHE"), name+"-"+archname), false
-}
-
 // CFlags returns the flags to pass to the C compiler. This is necessary for CGo
 // preprocessing.
 func (c *Config) CFlags() []string {
-	var cflags []string
+	cflags := append([]string{}, c.Options.CFlags...)
 	for _, flag := range c.Target.CFlags {
-		cflags = append(cflags, strings.ReplaceAll(flag, "{root}", goenv.Get("TINYGOROOT")))
+		cflags = append(cflags, strings.Replace(flag, "{root}", goenv.Get("TINYGOROOT"), -1))
 	}
-	switch c.Target.Libc {
-	case "picolibc":
+	if c.Target.Libc == "picolibc" {
 		root := goenv.Get("TINYGOROOT")
-		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
-		path, _ := c.LibcPath("picolibc")
-		cflags = append(cflags,
-			"--sysroot="+path,
-			"-isystem", filepath.Join(picolibcDir, "include"),
-			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
-		)
-	case "musl":
-		root := goenv.Get("TINYGOROOT")
-		path, _ := c.LibcPath("musl")
-		arch := MuslArchitecture(c.Triple())
-		cflags = append(cflags,
-			"-nostdlibinc",
-			"-isystem", filepath.Join(path, "include"),
-			"-isystem", filepath.Join(root, "lib", "musl", "arch", arch),
-			"-isystem", filepath.Join(root, "lib", "musl", "include"),
-		)
-	case "wasi-libc":
-		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags, "--sysroot="+root+"/lib/wasi-libc/sysroot")
-	case "mingw-w64":
-		root := goenv.Get("TINYGOROOT")
-		path, _ := c.LibcPath("mingw-w64")
-		cflags = append(cflags,
-			"--sysroot="+path,
-			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "crt"),
-			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "defaults", "include"),
-			"-D_UCRT",
-		)
-	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)
-	}
-	// 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)
-		}
+		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"))
 	}
 	return cflags
 }
@@ -291,11 +185,17 @@ func (c *Config) CFlags() []string {
 func (c *Config) LDFlags() []string {
 	root := goenv.Get("TINYGOROOT")
 	// Merge and adjust LDFlags.
-	var ldflags []string
+	ldflags := append([]string{}, c.Options.LDFlags...)
 	for _, flag := range c.Target.LDFlags {
-		ldflags = append(ldflags, strings.ReplaceAll(flag, "{root}", root))
+		ldflags = append(ldflags, strings.Replace(flag, "{root}", root, -1))
 	}
 	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)
 	}
@@ -320,43 +220,12 @@ func (c *Config) VerifyIR() bool {
 	return c.Options.VerifyIR
 }

-// 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.
+// Debug returns whether to add debug symbols to the IR, for debugging with GDB
+// and similar.
 func (c *Config) Debug() bool {
 	return c.Options.Debug
 }

-// BinaryFormat returns an appropriate binary format, based on the file
-// extension and the configured binary format in the target JSON file.
-func (c *Config) BinaryFormat(ext string) string {
-	switch ext {
-	case ".bin", ".gba", ".nro":
-		// The simplest format possible: dump everything in a raw binary file.
-		if c.Target.BinaryFormat != "" {
-			return c.Target.BinaryFormat
-		}
-		return "bin"
-	case ".hex":
-		// Similar to bin, but includes the start address and is thus usually a
-		// better format.
-		return "hex"
-	case ".uf2":
-		// Special purpose firmware format, mainly used on Adafruit boards.
-		// 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"
-	}
-}
-
 // Programmer returns the flash method and OpenOCD interface name given a
 // particular configuration. It may either be all configured in the target JSON
 // file or be modified using the -programmmer command-line option.
@@ -368,9 +237,6 @@ 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.
@@ -399,9 +265,6 @@ 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)
 	}
@@ -409,43 +272,6 @@ func (c *Config) OpenOCDConfiguration() (args []string, err error) {
 	return args, nil
 }

-// CodeModel returns the code model used on this platform.
-func (c *Config) CodeModel() string {
-	if c.Target.CodeModel != "" {
-		return c.Target.CodeModel
-	}
-
-	return "default"
-}
-
-// RelocationModel returns the relocation model in use on this platform. Valid
-// values are "static", "pic", "dynamicnopic".
-func (c *Config) RelocationModel() string {
-	if c.Target.RelocationModel != "" {
-		return c.Target.RelocationModel
-	}
-
-	return "static"
-}
-
-// WasmAbi returns the WASM ABI which is specified in the target JSON file, and
-// the value is overridden by `-wasm-abi` flag if it is provided
-func (c *Config) WasmAbi() string {
-	if c.Options.WasmAbi != "" {
-		return c.Options.WasmAbi
-	}
-	return c.Target.WasmAbi
-}
-
-// Emulator returns the emulator target config
-func (c *Config) Emulator() []string {
-	var emulator []string
-	for _, s := range c.Target.Emulator {
-		emulator = append(emulator, strings.ReplaceAll(s, "{root}", goenv.Get("TINYGOROOT")))
-	}
-	return emulator
-}
-
 type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc
@@ -1,113 +1,23 @@
 package compileopts

-import (
-	"fmt"
-	"regexp"
-	"strings"
-)
-
-var (
-	validGCOptions            = []string{"none", "leaking", "conservative"}
-	validSchedulerOptions     = []string{"none", "tasks", "asyncify"}
-	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, but can also be passed in environment
-// variables for example.
+// usually passed from the command line.
 type Options struct {
-	GOOS            string // environment variable
-	GOARCH          string // environment variable
-	GOARM           string // environment variable (only used with GOARCH=arm)
-	Target          string
-	Opt             string
-	GC              string
-	PanicStrategy   string
-	Scheduler       string
-	Serial          string
-	PrintIR         bool
-	DumpSSA         bool
-	VerifyIR        bool
-	PrintCommands   func(cmd string, args ...string)
-	Semaphore       chan struct{} // -p flag controls cap
-	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
-	Directory       string
-}
-
-// Verify performs a validation on the given options, raising an error if options are not valid.
-func (o *Options) Verify() error {
-	if o.GC != "" {
-		valid := isInArray(validGCOptions, o.GC)
-		if !valid {
-			return fmt.Errorf(`invalid gc option '%s': valid values are %s`,
-				o.GC,
-				strings.Join(validGCOptions, ", "))
-		}
-	}
-
-	if o.Scheduler != "" {
-		valid := isInArray(validSchedulerOptions, o.Scheduler)
-		if !valid {
-			return fmt.Errorf(`invalid scheduler option '%s': valid values are %s`,
-				o.Scheduler,
-				strings.Join(validSchedulerOptions, ", "))
-		}
-	}
-
-	if o.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 {
-			return fmt.Errorf(`invalid size option '%s': valid values are %s`,
-				o.PrintSizes,
-				strings.Join(validPrintSizeOptions, ", "))
-		}
-	}
-
-	if o.PanicStrategy != "" {
-		valid := isInArray(validPanicStrategyOptions, o.PanicStrategy)
-		if !valid {
-			return fmt.Errorf(`invalid panic option '%s': valid values are %s`,
-				o.PanicStrategy,
-				strings.Join(validPanicStrategyOptions, ", "))
-		}
-	}
-
-	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
-}
-
-func isInArray(arr []string, item string) bool {
-	for _, i := range arr {
-		if i == item {
-			return true
-		}
-	}
-	return false
+	Target        string
+	Opt           string
+	GC            string
+	PanicStrategy string
+	Scheduler     string
+	PrintIR       bool
+	DumpSSA       bool
+	VerifyIR      bool
+	Debug         bool
+	PrintSizes    string
+	CFlags        []string
+	LDFlags       []string
+	Tags          string
+	WasmAbi       string
+	HeapSize      int64
+	TestConfig    TestConfig
+	Programmer    string
 }
@@ -1,126 +0,0 @@
-package compileopts_test
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/tinygo-org/tinygo/compileopts"
-)
-
-func TestVerifyOptions(t *testing.T) {
-
-	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, conservative`)
-	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, asyncify`)
-	expectedPrintSizeError := errors.New(`invalid size option 'incorrect': valid values are none, short, full`)
-	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)
-
-	testCases := []struct {
-		name          string
-		opts          compileopts.Options
-		expectedError error
-	}{
-		{
-			name: "OptionsEmpty",
-			opts: compileopts.Options{},
-		},
-		{
-			name: "InvalidGCOption",
-			opts: compileopts.Options{
-				GC: "incorrect",
-			},
-			expectedError: expectedGCError,
-		},
-		{
-			name: "GCOptionNone",
-			opts: compileopts.Options{
-				GC: "none",
-			},
-		},
-		{
-			name: "GCOptionLeaking",
-			opts: compileopts.Options{
-				GC: "leaking",
-			},
-		},
-		{
-			name: "GCOptionConservative",
-			opts: compileopts.Options{
-				GC: "conservative",
-			},
-		},
-		{
-			name: "InvalidSchedulerOption",
-			opts: compileopts.Options{
-				Scheduler: "incorrect",
-			},
-			expectedError: expectedSchedulerError,
-		},
-		{
-			name: "SchedulerOptionNone",
-			opts: compileopts.Options{
-				Scheduler: "none",
-			},
-		},
-		{
-			name: "SchedulerOptionTasks",
-			opts: compileopts.Options{
-				Scheduler: "tasks",
-			},
-		},
-		{
-			name: "InvalidPrintSizeOption",
-			opts: compileopts.Options{
-				PrintSizes: "incorrect",
-			},
-			expectedError: expectedPrintSizeError,
-		},
-		{
-			name: "PrintSizeOptionNone",
-			opts: compileopts.Options{
-				PrintSizes: "none",
-			},
-		},
-		{
-			name: "PrintSizeOptionShort",
-			opts: compileopts.Options{
-				PrintSizes: "short",
-			},
-		},
-		{
-			name: "PrintSizeOptionFull",
-			opts: compileopts.Options{
-				PrintSizes: "full",
-			},
-		},
-		{
-			name: "InvalidPanicOption",
-			opts: compileopts.Options{
-				PanicStrategy: "incorrect",
-			},
-			expectedError: expectedPanicStrategyError,
-		},
-		{
-			name: "PanicOptionPrint",
-			opts: compileopts.Options{
-				PanicStrategy: "print",
-			},
-		},
-		{
-			name: "PanicOptionTrap",
-			opts: compileopts.Options{
-				PanicStrategy: "trap",
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			err := tc.opts.Verify()
-			if tc.expectedError != err {
-				if tc.expectedError.Error() != err.Error() {
-					t.Errorf("expected %v, got %v", tc.expectedError, err)
-				}
-			}
-		})
-	}
-}
@@ -5,18 +5,13 @@ package compileopts
 import (
 	"encoding/json"
 	"errors"
-	"fmt"
 	"io"
 	"os"
-	"os/exec"
 	"path/filepath"
-	"reflect"
 	"runtime"
-	"strconv"
 	"strings"

 	"github.com/tinygo-org/tinygo/goenv"
-	"tinygo.org/x/go-llvm"
 )

 // Target specification for a given target. Used for bare metal targets.
@@ -28,83 +23,112 @@ type TargetSpec struct {
 	Inherits         []string `json:"inherits"`
 	Triple           string   `json:"llvm-target"`
 	CPU              string   `json:"cpu"`
-	Features         string   `json:"features"`
+	Features         []string `json:"features"`
 	GOOS             string   `json:"goos"`
 	GOARCH           string   `json:"goarch"`
 	BuildTags        []string `json:"build-tags"`
 	GC               string   `json:"gc"`
 	Scheduler        string   `json:"scheduler"`
-	Serial           string   `json:"serial"` // which serial output to use (uart, usb, none)
+	Compiler         string   `json:"compiler"`
 	Linker           string   `json:"linker"`
 	RTLib            string   `json:"rtlib"` // compiler runtime library (libgcc, compiler-rt)
 	Libc             string   `json:"libc"`
-	AutoStackSize    *bool    `json:"automatic-stack-size"` // Determine stack size automatically at compile time.
-	DefaultStackSize uint64   `json:"default-stack-size"`   // Default stack size if the size couldn't be determined at compile time.
 	CFlags           []string `json:"cflags"`
 	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
+	Emulator         []string `json:"emulator"`
 	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"`
 	UF2FamilyID      string   `json:"uf2-family-id"`
-	BinaryFormat     string   `json:"binary-format"`
 	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"`
-	WasmAbi          string   `json:"wasm-abi"`
 }

-// overrideProperties overrides all properties that are set in child into itself using reflection.
-func (spec *TargetSpec) overrideProperties(child *TargetSpec) {
-	specType := reflect.TypeOf(spec).Elem()
-	specValue := reflect.ValueOf(spec).Elem()
-	childValue := reflect.ValueOf(child).Elem()
-
-	for i := 0; i < specType.NumField(); i++ {
-		field := specType.Field(i)
-		src := childValue.Field(i)
-		dst := specValue.Field(i)
-
-		switch kind := field.Type.Kind(); kind {
-		case reflect.String: // for strings, just copy the field of child to spec if not empty
-			if src.Len() > 0 {
-				dst.Set(src)
-			}
-		case reflect.Uint, reflect.Uint32, reflect.Uint64: // for Uint, copy if not zero
-			if src.Uint() != 0 {
-				dst.Set(src)
-			}
-		case reflect.Ptr: // for pointers, copy if not nil
-			if !src.IsNil() {
-				dst.Set(src)
-			}
-		case reflect.Slice: // for slices...
-			if src.Len() > 0 { // ... if not empty ...
-				switch tag := field.Tag.Get("override"); tag {
-				case "copy":
-					// copy the field of child to spec
-					dst.Set(src)
-				case "append", "":
-					// or append the field of child to spec
-					dst.Set(reflect.AppendSlice(dst, src))
-				default:
-					panic("override mode must be 'copy' or 'append' (default). I don't know how to '" + tag + "'.")
-				}
-			}
-		default:
-			panic("unknown field type : " + kind.String())
-		}
+// copyProperties copies all properties that are set in spec2 into itself.
+func (spec *TargetSpec) copyProperties(spec2 *TargetSpec) {
+	// TODO: simplify this using reflection? Inherits and BuildTags are special
+	// cases, but the rest can simply be copied if set.
+	spec.Inherits = append(spec.Inherits, spec2.Inherits...)
+	if spec2.Triple != "" {
+		spec.Triple = spec2.Triple
+	}
+	if spec2.CPU != "" {
+		spec.CPU = spec2.CPU
+	}
+	spec.Features = append(spec.Features, spec2.Features...)
+	if spec2.GOOS != "" {
+		spec.GOOS = spec2.GOOS
+	}
+	if spec2.GOARCH != "" {
+		spec.GOARCH = spec2.GOARCH
+	}
+	spec.BuildTags = append(spec.BuildTags, spec2.BuildTags...)
+	if spec2.GC != "" {
+		spec.GC = spec2.GC
+	}
+	if spec2.Scheduler != "" {
+		spec.Scheduler = spec2.Scheduler
+	}
+	if spec2.Compiler != "" {
+		spec.Compiler = spec2.Compiler
+	}
+	if spec2.Linker != "" {
+		spec.Linker = spec2.Linker
+	}
+	if spec2.RTLib != "" {
+		spec.RTLib = spec2.RTLib
+	}
+	if spec2.Libc != "" {
+		spec.Libc = spec2.Libc
+	}
+	spec.CFlags = append(spec.CFlags, spec2.CFlags...)
+	spec.LDFlags = append(spec.LDFlags, spec2.LDFlags...)
+	if spec2.LinkerScript != "" {
+		spec.LinkerScript = spec2.LinkerScript
+	}
+	spec.ExtraFiles = append(spec.ExtraFiles, spec2.ExtraFiles...)
+	if len(spec2.Emulator) != 0 {
+		spec.Emulator = spec2.Emulator
+	}
+	if spec2.FlashCommand != "" {
+		spec.FlashCommand = spec2.FlashCommand
+	}
+	if spec2.GDB != "" {
+		spec.GDB = spec2.GDB
+	}
+	if spec2.PortReset != "" {
+		spec.PortReset = spec2.PortReset
+	}
+	if spec2.FlashMethod != "" {
+		spec.FlashMethod = spec2.FlashMethod
+	}
+	if spec2.FlashVolume != "" {
+		spec.FlashVolume = spec2.FlashVolume
+	}
+	if spec2.FlashFilename != "" {
+		spec.FlashFilename = spec2.FlashFilename
+	}
+	if spec2.UF2FamilyID != "" {
+		spec.UF2FamilyID = spec2.UF2FamilyID
+	}
+	if spec2.OpenOCDInterface != "" {
+		spec.OpenOCDInterface = spec2.OpenOCDInterface
+	}
+	if spec2.OpenOCDTarget != "" {
+		spec.OpenOCDTarget = spec2.OpenOCDTarget
+	}
+	if spec2.OpenOCDTransport != "" {
+		spec.OpenOCDTransport = spec2.OpenOCDTransport
+	}
+	if spec2.JLinkDevice != "" {
+		spec.JLinkDevice = spec2.JLinkDevice
 	}
 }

@@ -153,195 +177,125 @@ func (spec *TargetSpec) resolveInherits() error {
 		if err != nil {
 			return err
 		}
-		newSpec.overrideProperties(subtarget)
+		newSpec.copyProperties(subtarget)
 	}

 	// When all properties are loaded, make sure they are properly inherited.
-	newSpec.overrideProperties(spec)
+	newSpec.copyProperties(spec)
 	*spec = *newSpec

 	return nil
 }

 // Load a target specification.
-func LoadTarget(options *Options) (*TargetSpec, error) {
-	if options.Target == "" {
+func LoadTarget(target string) (*TargetSpec, error) {
+	if target == "" {
 		// Configure based on GOOS/GOARCH environment variables (falling back to
 		// runtime.GOOS/runtime.GOARCH), and generate a LLVM target based on it.
-		var llvmarch string
-		switch options.GOARCH {
-		case "386":
-			llvmarch = "i386"
-		case "amd64":
-			llvmarch = "x86_64"
-		case "arm64":
-			llvmarch = "aarch64"
-		case "arm":
-			switch options.GOARM {
-			case "5":
-				llvmarch = "armv5"
-			case "6":
-				llvmarch = "armv6"
-			case "7":
-				llvmarch = "armv7"
-			default:
-				return nil, fmt.Errorf("invalid GOARM=%s, must be 5, 6, or 7", options.GOARM)
-			}
-		default:
-			llvmarch = options.GOARCH
+		goos := goenv.Get("GOOS")
+		goarch := goenv.Get("GOARCH")
+		llvmos := goos
+		llvmarch := map[string]string{
+			"386":   "i386",
+			"amd64": "x86_64",
+			"arm64": "aarch64",
+		}[goarch]
+		if llvmarch == "" {
+			llvmarch = goarch
 		}
-		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 = llvmarch + "--" + llvmos
+		if goarch == "arm" {
 			target += "-gnueabihf"
 		}
-		if options.GOOS == "windows" {
-			target += "-gnu"
-		}
-		return defaultTarget(options.GOOS, options.GOARCH, target)
+		return defaultTarget(goos, goarch, target)
 	}

 	// See whether there is a target specification for this target (e.g.
 	// Arduino).
 	spec := &TargetSpec{}
-	err := spec.loadFromGivenStr(options.Target)
-	if err != nil {
+	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.
 		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",
+			"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
-	}
-
-	if spec.Scheduler == "asyncify" {
-		spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_asyncify_wasm.S")
-	}
-
-	return spec, nil
 }

 func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 	// 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},
-		Scheduler:        "tasks",
-		Linker:           "cc",
-		DefaultStackSize: 1024 * 64, // 64kB
-		GDB:              []string{"gdb"},
-		PortReset:        "false",
-	}
-	switch goarch {
-	case "386":
-		spec.CPU = "pentium4"
-		spec.Features = "+cx8,+fxsr,+mmx,+sse,+sse2,+x87"
-	case "amd64":
-		spec.CPU = "x86-64"
-		spec.Features = "+cx8,+fxsr,+mmx,+sse,+sse2,+x87"
-	case "arm":
-		spec.CPU = "generic"
-		spec.CFlags = append(spec.CFlags, "-fno-unwind-tables")
-		switch strings.Split(triple, "-")[0] {
-		case "armv5":
-			spec.Features = "+armv5t,+strict-align,-aes,-bf16,-d32,-dotprod,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-mve.fp,-neon,-sha2,-thumb-mode,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp"
-		case "armv6":
-			spec.Features = "+armv6,+dsp,+fp64,+strict-align,+vfp2,+vfp2sp,-aes,-d32,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fullfp16,-neon,-sha2,-thumb-mode,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp"
-		case "armv7":
-			spec.Features = "+armv7-a,+d32,+dsp,+fp64,+neon,+vfp2,+vfp2sp,+vfp3,+vfp3d16,+vfp3d16sp,+vfp3sp,-aes,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fullfp16,-sha2,-thumb-mode,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp"
-		}
-	case "arm64":
-		spec.CPU = "generic"
-		spec.Features = "+neon"
+		Triple:      triple,
+		GOOS:        goos,
+		GOARCH:      goarch,
+		BuildTags:   []string{goos, goarch},
+		Compiler:    "clang",
+		Linker:      "cc",
+		CFlags:      []string{"--target=" + triple},
+		GDB:         "gdb",
+		PortReset:   "false",
+		FlashMethod: "native",
 	}
 	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 if goos == "windows" {
-		spec.Linker = "ld.lld"
-		spec.Libc = "mingw-w64"
-		// Note: using a medium code model, low image base and no ASLR
-		// because Go doesn't really need those features. ASLR patches
-		// around issues for unsafe languages like C/C++ that are not
-		// normally present in Go (without explicitly opting in).
-		// For more discussion:
-		// https://groups.google.com/g/Golang-nuts/c/Jd9tlNc6jUE/m/Zo-7zIP_m3MJ?pli=1
-		spec.LDFlags = append(spec.LDFlags,
-			"-m", "i386pep",
-			"-Bdynamic",
-			"--image-base", "0x400000",
-			"--gc-sections",
-			"--no-insert-timestamp",
-		)
-		llvmMajor, _ := strconv.Atoi(strings.Split(llvm.Version, ".")[0])
-		if llvmMajor >= 12 {
-			// This flag was added in LLVM 12. At the same time, LLVM 12
-			// switched the default from --dynamicbase to --no-dynamicbase.
-			spec.LDFlags = append(spec.LDFlags, "--no-dynamicbase")
-		}
 	} else {
 		spec.LDFlags = append(spec.LDFlags, "-no-pie", "-Wl,--gc-sections") // WARNING: clang < 5.0 requires -nopie
 	}
-	if goarch != "wasm" {
-		suffix := ""
-		if goos == "windows" {
-			// Windows uses a different calling convention from other operating
-			// systems so we need separate assembly files.
-			suffix = "_windows"
-		}
-		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/gc_"+goarch+suffix+".S")
-		spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_stack_"+goarch+suffix+".S")
-	}
 	if goarch != runtime.GOARCH {
 		// Some educated guesses as to how to invoke helper programs.
-		spec.GDB = []string{"gdb-multiarch"}
 		if goarch == "arm" && goos == "linux" {
-			spec.Emulator = []string{"qemu-arm"}
+			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/arm-linux-gnueabihf")
+			spec.Linker = "arm-linux-gnueabihf-gcc"
+			spec.GDB = "arm-linux-gnueabihf-gdb"
+			spec.Emulator = []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}
 		}
 		if goarch == "arm64" && goos == "linux" {
-			spec.Emulator = []string{"qemu-aarch64"}
+			spec.CFlags = append(spec.CFlags, "--sysroot=/usr/aarch64-linux-gnu")
+			spec.Linker = "aarch64-linux-gnu-gcc"
+			spec.GDB = "aarch64-linux-gnu-gdb"
+			spec.Emulator = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
 		}
-	}
-	if goos != runtime.GOOS {
-		if goos == "windows" {
-			spec.Emulator = []string{"wine"}
+		if goarch == "386" {
+			spec.CFlags = []string{"-m32"}
+			spec.LDFlags = []string{"-m32"}
 		}
 	}
 	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, ", ") + ")")
-}
@@ -1,87 +1,19 @@
 package compileopts

-import (
-	"os"
-	"reflect"
-	"testing"
-)
+import "testing"

 func TestLoadTarget(t *testing.T) {
-	_, err := LoadTarget(&Options{Target: "arduino"})
+	_, err := LoadTarget("arduino")
 	if err != nil {
 		t.Error("LoadTarget test failed:", err)
 	}

-	_, err = LoadTarget(&Options{Target: "notexist"})
+	_, err = LoadTarget("notexist")
 	if err == nil {
 		t.Error("LoadTarget should have failed with non existing target")
 	}

-	if !os.IsNotExist(err) {
+	if err.Error() != "expected a full LLVM target or a custom target in -target flag" {
 		t.Error("LoadTarget failed for wrong reason:", err)
 	}
 }
-
-func TestOverrideProperties(t *testing.T) {
-	baseAutoStackSize := true
-	base := &TargetSpec{
-		GOOS:             "baseGoos",
-		CPU:              "baseCpu",
-		CFlags:           []string{"-base-foo", "-base-bar"},
-		BuildTags:        []string{"bt1", "bt2"},
-		Emulator:         []string{"be1", "be2"},
-		DefaultStackSize: 42,
-		AutoStackSize:    &baseAutoStackSize,
-	}
-	childAutoStackSize := false
-	child := &TargetSpec{
-		GOOS:             "",
-		CPU:              "chlidCpu",
-		CFlags:           []string{"-child-foo", "-child-bar"},
-		Emulator:         []string{"ce1", "ce2"},
-		AutoStackSize:    &childAutoStackSize,
-		DefaultStackSize: 64,
-	}
-
-	base.overrideProperties(child)
-
-	if base.GOOS != "baseGoos" {
-		t.Errorf("Overriding failed : got %v", base.GOOS)
-	}
-	if base.CPU != "chlidCpu" {
-		t.Errorf("Overriding failed : got %v", base.CPU)
-	}
-	if !reflect.DeepEqual(base.CFlags, []string{"-base-foo", "-base-bar", "-child-foo", "-child-bar"}) {
-		t.Errorf("Overriding failed : got %v", base.CFlags)
-	}
-	if !reflect.DeepEqual(base.BuildTags, []string{"bt1", "bt2"}) {
-		t.Errorf("Overriding failed : got %v", base.BuildTags)
-	}
-	if !reflect.DeepEqual(base.Emulator, []string{"ce1", "ce2"}) {
-		t.Errorf("Overriding failed : got %v", base.Emulator)
-	}
-	if *base.AutoStackSize != false {
-		t.Errorf("Overriding failed : got %v", base.AutoStackSize)
-	}
-	if base.DefaultStackSize != 64 {
-		t.Errorf("Overriding failed : got %v", base.DefaultStackSize)
-	}
-
-	baseAutoStackSize = true
-	base = &TargetSpec{
-		AutoStackSize:    &baseAutoStackSize,
-		DefaultStackSize: 42,
-	}
-	child = &TargetSpec{
-		AutoStackSize:    nil,
-		DefaultStackSize: 0,
-	}
-	base.overrideProperties(child)
-	if *base.AutoStackSize != true {
-		t.Errorf("Overriding failed : got %v", base.AutoStackSize)
-	}
-	if base.DefaultStackSize != 42 {
-		t.Errorf("Overriding failed : got %v", base.DefaultStackSize)
-	}
-
-}
@@ -1,102 +0,0 @@
-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)
-	}
-}
@@ -15,16 +15,22 @@ import (
 // createLookupBoundsCheck emits a bounds check before doing a lookup into a
 // slice. This is required by the Go language spec: an index out of bounds must
 // cause a panic.
-// The caller should make sure that index is at least as big as arrayLen.
-func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value) {
+func (b *builder) createLookupBoundsCheck(arrayLen, index llvm.Value, indexType types.Type) {
 	if b.info.nobounds {
 		// The //go:nobounds pragma was added to the function to avoid bounds
 		// checking.
 		return
 	}

-	// Extend arrayLen if it's too small.
-	if index.Type().IntTypeWidth() > arrayLen.Type().IntTypeWidth() {
+	if index.Type().IntTypeWidth() < arrayLen.Type().IntTypeWidth() {
+		// Sometimes, the index can be e.g. an uint8 or int8, and we have to
+		// correctly extend that type.
+		if indexType.Underlying().(*types.Basic).Info()&types.IsUnsigned == 0 {
+			index = b.CreateZExt(index, arrayLen.Type(), "")
+		} else {
+			index = b.CreateSExt(index, arrayLen.Type(), "")
+		}
+	} else if index.Type().IntTypeWidth() > arrayLen.Type().IntTypeWidth() {
 		// The index is bigger than the array length type, so extend it.
 		arrayLen = b.CreateZExt(arrayLen, index.Type(), "")
 	}
@@ -64,9 +70,27 @@ func (b *builder) createSliceBoundsCheck(capacity, low, high, max llvm.Value, lo
 	}

 	// Extend low and high to be the same size as capacity.
-	low = b.extendInteger(low, lowType, capacityType)
-	high = b.extendInteger(high, highType, capacityType)
-	max = b.extendInteger(max, maxType, capacityType)
+	if low.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
+		if lowType.Info()&types.IsUnsigned != 0 {
+			low = b.CreateZExt(low, capacityType, "")
+		} else {
+			low = b.CreateSExt(low, capacityType, "")
+		}
+	}
+	if high.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
+		if highType.Info()&types.IsUnsigned != 0 {
+			high = b.CreateZExt(high, capacityType, "")
+		} else {
+			high = b.CreateSExt(high, capacityType, "")
+		}
+	}
+	if max.Type().IntTypeWidth() < capacityType.IntTypeWidth() {
+		if maxType.Info()&types.IsUnsigned != 0 {
+			max = b.CreateZExt(max, capacityType, "")
+		} else {
+			max = b.CreateSExt(max, capacityType, "")
+		}
+	}

 	// Now do the bounds check: low > high || high > capacity
 	outOfBounds1 := b.CreateICmp(llvm.IntUGT, low, high, "slice.lowhigh")
@@ -77,49 +101,6 @@ 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.
-	len = b.extendInteger(len, lenType, 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) {
@@ -129,8 +110,19 @@ func (b *builder) createChanBoundsCheck(elementSize uint64, bufSize llvm.Value,
 		return
 	}

-	// Make sure bufSize is at least as big as maxBufSize (an uintptr).
-	bufSize = b.extendInteger(bufSize, bufSizeType, b.uintptrType)
+	// Check whether the bufSize parameter must be cast to a wider integer for
+	// comparison.
+	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, "")
+		}
+	}

 	// Calculate (^uintptr(0)) >> 1, which is the max value that fits in an
 	// uintptr if uintptrs were signed.
@@ -167,13 +159,6 @@ 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
@@ -214,19 +199,6 @@ 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) {
@@ -255,19 +227,3 @@ func (b *builder) createRuntimeAssert(assert llvm.Value, blockPrefix, assertFunc
 	// Ok: assert didn't trigger so continue normally.
 	b.SetInsertPointAtEnd(nextBlock)
 }
-
-// extendInteger extends the value to at least targetType using a zero or sign
-// extend. The resulting value is not truncated: it may still be bigger than
-// targetType.
-func (b *builder) extendInteger(value llvm.Value, valueType types.Type, targetType llvm.Type) llvm.Value {
-	if value.Type().IntTypeWidth() < targetType.IntTypeWidth() {
-		if valueType.Underlying().(*types.Basic).Info()&types.IsUnsigned != 0 {
-			// Unsigned, so zero-extend to the target type.
-			value = b.CreateZExt(value, targetType, "")
-		} else {
-			// Signed, so sign-extend to the target type.
-			value = b.CreateSExt(value, targetType, "")
-		}
-	}
-	return value
-}
@@ -1,115 +0,0 @@
-package compiler
-
-import (
-	"fmt"
-	"strings"
-
-	"golang.org/x/tools/go/ssa"
-	"tinygo.org/x/go-llvm"
-)
-
-// createAtomicOp lowers an atomic library call by lowering it as an LLVM atomic
-// operation. It returns the result of the operation and true if the call could
-// be lowered inline, and false otherwise.
-func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
-	name := call.Value.(*ssa.Function).Name()
-	switch name {
-	case "AddInt32", "AddInt64", "AddUint32", "AddUint64", "AddUintptr":
-		ptr := b.getValue(call.Args[0])
-		val := b.getValue(call.Args[1])
-		if strings.HasPrefix(b.Triple, "avr") {
-			// AtomicRMW does not work on AVR as intended:
-			// - There are some register allocation issues (fixed by https://reviews.llvm.org/D97127 which is not yet in a usable LLVM release)
-			// - The result is the new value instead of the old value
-			vType := val.Type()
-			name := fmt.Sprintf("__sync_fetch_and_add_%d", vType.IntTypeWidth()/8)
-			fn := b.mod.NamedFunction(name)
-			if fn.IsNil() {
-				fn = llvm.AddFunction(b.mod, name, llvm.FunctionType(vType, []llvm.Type{ptr.Type(), vType}, false))
-			}
-			oldVal := b.createCall(fn, []llvm.Value{ptr, val}, "")
-			// Return the new value, not the original value returned.
-			return b.CreateAdd(oldVal, val, ""), true
-		}
-		oldVal := b.CreateAtomicRMW(llvm.AtomicRMWBinOpAdd, ptr, val, llvm.AtomicOrderingSequentiallyConsistent, true)
-		// Return the new value, not the original value returned by atomicrmw.
-		return b.CreateAdd(oldVal, val, ""), true
-	case "SwapInt32", "SwapInt64", "SwapUint32", "SwapUint64", "SwapUintptr", "SwapPointer":
-		ptr := b.getValue(call.Args[0])
-		val := b.getValue(call.Args[1])
-		isPointer := val.Type().TypeKind() == llvm.PointerTypeKind
-		if isPointer {
-			// atomicrmw only supports integers, so cast to an integer.
-			val = b.CreatePtrToInt(val, b.uintptrType, "")
-			ptr = b.CreateBitCast(ptr, llvm.PointerType(val.Type(), 0), "")
-		}
-		oldVal := b.CreateAtomicRMW(llvm.AtomicRMWBinOpXchg, ptr, val, llvm.AtomicOrderingSequentiallyConsistent, true)
-		if isPointer {
-			oldVal = b.CreateIntToPtr(oldVal, b.i8ptrType, "")
-		}
-		return oldVal, true
-	case "CompareAndSwapInt32", "CompareAndSwapInt64", "CompareAndSwapUint32", "CompareAndSwapUint64", "CompareAndSwapUintptr", "CompareAndSwapPointer":
-		ptr := b.getValue(call.Args[0])
-		old := b.getValue(call.Args[1])
-		newVal := b.getValue(call.Args[2])
-		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
-	case "LoadInt32", "LoadInt64", "LoadUint32", "LoadUint64", "LoadUintptr", "LoadPointer":
-		ptr := b.getValue(call.Args[0])
-		val := b.CreateLoad(ptr, "")
-		val.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
-		val.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
-		return val, true
-	case "StoreInt32", "StoreInt64", "StoreUint32", "StoreUint64", "StoreUintptr", "StorePointer":
-		ptr := b.getValue(call.Args[0])
-		val := b.getValue(call.Args[1])
-		if strings.HasPrefix(b.Triple, "avr") {
-			// SelectionDAGBuilder is currently missing the "are unaligned atomics allowed" check for stores.
-			vType := val.Type()
-			isPointer := vType.TypeKind() == llvm.PointerTypeKind
-			if isPointer {
-				// libcalls only supports integers, so cast to an integer.
-				vType = b.uintptrType
-				val = b.CreatePtrToInt(val, vType, "")
-				ptr = b.CreateBitCast(ptr, llvm.PointerType(vType, 0), "")
-			}
-			name := fmt.Sprintf("__atomic_store_%d", vType.IntTypeWidth()/8)
-			fn := b.mod.NamedFunction(name)
-			if fn.IsNil() {
-				fn = llvm.AddFunction(b.mod, name, llvm.FunctionType(vType, []llvm.Type{ptr.Type(), vType, b.uintptrType}, false))
-			}
-			return b.createCall(fn, []llvm.Value{ptr, val, llvm.ConstInt(b.uintptrType, 5, false)}, ""), true
-		}
-		store := b.CreateStore(val, ptr)
-		store.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
-		store.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
-		return store, true
-	default:
-		return llvm.Value{}, false
-	}
-}
@@ -4,7 +4,6 @@ import (
 	"go/types"
 	"strconv"

-	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )

@@ -35,12 +34,11 @@ 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 {
-	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
+	llvmFn := b.getFunctionRaw(b.getRuntimeFuncType(fnName), functionInfo{
+		linkName: "runtime." + fnName,
+	})
+	args = append(args, llvm.Undef(b.i8ptrType))            // unused context parameter
+	args = append(args, llvm.ConstPointerNull(b.i8ptrType)) // coroutine handle
 	return b.createCall(llvmFn, args, name)
 }

@@ -57,15 +55,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 (c *compilerContext) expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
+func expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		fieldInfos := c.flattenAggregateType(t, name, goType)
+		fieldInfos := 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 +102,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 := b.flattenAggregateType(v.Type(), "", nil)
+		fieldInfos := flattenAggregateType(v.Type(), "", nil)
 		if len(fieldInfos) <= maxFieldsPerParam {
 			fields := b.flattenAggregate(v)
 			if len(fields) != len(fieldInfos) {
@@ -123,15 +121,12 @@ 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 (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
+func flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
 	typeFlags := getTypeFlags(goType)
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		var paramInfos []paramInfo
+		paramInfos := make([]paramInfo, 0, t.StructElementTypesCount())
 		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,
@@ -154,7 +149,7 @@ func (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType
 					suffix = []string{"context", "funcptr"}[i]
 				}
 			}
-			subInfos := c.flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
+			subInfos := flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
 			for i := range subInfos {
 				subInfos[i].flags |= typeFlags
 			}
@@ -220,11 +215,8 @@ func extractSubfield(t types.Type, field int) types.Type {
 func (c *compilerContext) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
-		var fields []uint64
+		fields := make([]uint64, 0, t.StructElementTypesCount())
 		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 {
@@ -243,11 +235,8 @@ func (c *compilerContext) flattenAggregateTypeOffsets(t llvm.Type) []uint64 {
 func (b *builder) flattenAggregate(v llvm.Value) []llvm.Value {
 	switch v.Type().TypeKind() {
 	case llvm.StructTypeKind:
-		var fields []llvm.Value
-		for i, field := range v.Type().StructElementTypes() {
-			if b.targetData.TypeAllocSize(field) == 0 {
-				continue
-			}
+		fields := make([]llvm.Value, 0, v.Type().StructElementTypesCount())
+		for i := range v.Type().StructElementTypes() {
 			subfield := b.CreateExtractValue(v, i, "")
 			subfields := b.flattenAggregate(subfield)
 			fields = append(fields, subfields...)
@@ -274,13 +263,10 @@ 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 := b.flattenAggregateType(t, "", nil)
+		flattened := 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, "")
@@ -12,7 +12,7 @@ import (
 )

 func (b *builder) createMakeChan(expr *ssa.MakeChan) llvm.Value {
-	elementSize := b.targetData.TypeAllocSize(b.getLLVMType(expr.Type().Underlying().(*types.Chan).Elem()))
+	elementSize := b.targetData.TypeAllocSize(b.getLLVMType(expr.Type().(*types.Chan).Elem()))
 	elementSizeValue := llvm.ConstInt(b.uintptrType, elementSize, false)
 	bufSize := b.getValue(expr.Size)
 	b.createChanBoundsCheck(elementSize, bufSize, expr.Size.Type().Underlying().(*types.Basic), expr.Pos())
@@ -32,62 +32,31 @@ func (b *builder) createChanSend(instr *ssa.Send) {

 	// store value-to-send
 	valueType := b.getLLVMType(instr.X.Type())
-	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")
-	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
+	b.CreateStore(chanValue, valueAlloca)

 	// Do the send.
-	b.createRuntimeCall("chanSend", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")
+	b.createRuntimeCall("chanSend", []llvm.Value{ch, valueAllocaCast}, "")

-	// End the lifetime of the allocas.
+	// End the lifetime of the alloca.
 	// This also works around a bug in CoroSplit, at least in LLVM 8:
 	// https://bugs.llvm.org/show_bug.cgi?id=41742
-	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
-	if !isZeroSize {
-		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
-	}
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 }

 // createChanRecv emits a pseudo chan receive operation. It is lowered to the
 // actual channel receive operation during goroutine lowering.
 func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
-	valueType := b.getLLVMType(unop.X.Type().Underlying().(*types.Chan).Elem())
+	valueType := b.getLLVMType(unop.X.Type().(*types.Chan).Elem())
 	ch := b.getValue(unop.X)

 	// Allocate memory to receive into.
-	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")
-	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")

 	// Do the receive.
-	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast, channelBlockedListAlloca}, "")
-	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)
+	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAllocaCast}, "")
+	received := b.CreateLoad(valueAlloca, "chan.received")
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)

 	if unop.CommaOk {
 		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false))
@@ -100,7 +69,8 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 }

 // createChanClose closes the given channel.
-func (b *builder) createChanClose(ch llvm.Value) {
+func (b *builder) createChanClose(param ssa.Value) {
+	ch := b.getValue(param)
 	b.createRuntimeCall("chanClose", []llvm.Value{ch}, "")
 }

@@ -137,6 +107,7 @@ 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 {
@@ -146,13 +117,14 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 		switch state.Dir {
 		case types.RecvOnly:
 			// Make sure the receive buffer is big enough and has the correct alignment.
-			llvmType := b.getLLVMType(state.Chan.Type().Underlying().(*types.Chan).Elem())
+			llvmType := b.getLLVMType(state.Chan.Type().(*types.Chan).Elem())
 			if size := b.targetData.TypeAllocSize(llvmType); size > recvbufSize {
 				recvbufSize = size
 			}
 			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.
@@ -169,7 +141,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 recvbufSize != 0 {
+	if hasReceives {
 		allocaType := llvm.ArrayType(b.ctx.Int8Type(), int(recvbufSize))
 		recvbufAlloca, _, _ := b.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
 		recvbufAlloca.SetAlignment(recvbufAlign)
@@ -1,237 +1,138 @@
 package compiler

 import (
+	"bytes"
 	"flag"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
 	"go/types"
 	"io/ioutil"
-	"strconv"
+	"path/filepath"
 	"strings"
+	"sync"
 	"testing"

 	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
-	"github.com/tinygo-org/tinygo/loader"
+	"github.com/tinygo-org/tinygo/compiler/ircheck"
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
 	"tinygo.org/x/go-llvm"
 )

-// 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")
+var flagUpdate = flag.Bool("update", false, "update all tests")

-type testCase struct {
-	file      string
-	target    string
-	scheduler 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)
-	}
-
-	// Determine Go minor version (e.g. 16 in go1.16.3).
-	_, goMinor, err := goenv.GetGorootVersion(goenv.Get("GOROOT"))
-	if err != nil {
-		t.Fatal("could not read Go version:", err)
-	}
-
-	// Determine which tests to run, depending on the Go and LLVM versions.
-	tests := []testCase{
-		{"basic.go", "", ""},
-		{"pointer.go", "", ""},
-		{"slice.go", "", ""},
-		{"string.go", "", ""},
-		{"float.go", "", ""},
-		{"interface.go", "", ""},
-		{"func.go", "", ""},
-		{"pragma.go", "", ""},
-		{"goroutine.go", "wasm", "asyncify"},
-		{"goroutine.go", "cortex-m-qemu", "tasks"},
-		{"channel.go", "", ""},
-		{"intrinsics.go", "cortex-m-qemu", ""},
-		{"intrinsics.go", "wasm", ""},
-		{"gc.go", "", ""},
-	}
-	if llvmMajor >= 12 {
-		tests = append(tests, testCase{"intrinsics.go", "cortex-m-qemu", ""})
-		tests = append(tests, testCase{"intrinsics.go", "wasm", ""})
-	}
-	if goMinor >= 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.target
-		}
-		if tc.scheduler != "" {
-			name += "-" + tc.scheduler
-		}
-
+	for _, name := range []string{"basic"} {
 		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)
-			}
-			if tc.scheduler != "" {
-				options.Scheduler = tc.scheduler
-			}
-			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(),
-				AutomaticStackSize: config.AutomaticStackSize(),
-				DefaultStackSize:   config.Target.DefaultStackSize,
-				NeedsStackObjects:  config.NeedsStackObjects(),
-			}
-			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
-			}
-			if tc.scheduler != "" {
-				outFilePrefix += "-" + tc.scheduler
-			}
-			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())
-			}
+			runCompilerTest(t, name)
 		})
 	}
 }

-// 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
-	llvmVersion, err := strconv.Atoi(strings.Split(llvm.Version, ".")[0])
+func runCompilerTest(t *testing.T, name string) {
+	// Read the AST in memory.
+	path := filepath.Join("testdata", name+".go")
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, path, nil, parser.ParseComments)
 	if err != nil {
-		// Note: this should never happen and if it does, it will always happen
-		// for a particular build because llvm.Version is a constant.
-		panic(err)
+		t.Fatal("could not parse Go source file:", err)
 	}
-	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
-		}
-		if llvmVersion < 12 && strings.HasPrefix(line, "attributes ") {
-			// Ignore attribute groups. These may change between LLVM versions.
-			// Right now test outputs are for LLVM 12 and higher.
-			continue
-		}
-		if llvmVersion < 13 && strings.HasPrefix(line, "target datalayout = ") {
-			// The datalayout string may vary betewen LLVM versions.
-			// Right now test outputs are for LLVM 13 and higher.
-			continue
-		}
-		out = append(out, line)
+	files := []*ast.File{f}
+
+	// Create Go SSA from the AST.
+	var typecheckErrors []error
+	var typecheckErrorsLock sync.Mutex
+	typesConfig := types.Config{
+		Error: func(err error) {
+			typecheckErrorsLock.Lock()
+			defer typecheckErrorsLock.Unlock()
+			typecheckErrors = append(typecheckErrors, err)
+		},
+		Importer: simpleImporter{},
+		Sizes:    types.SizesFor("gccgo", "arm"),
+	}
+	pkg, _, err := ssautil.BuildPackage(&typesConfig, fset, types.NewPackage("main", ""), files, ssa.SanityCheckFunctions|ssa.BareInits|ssa.GlobalDebug)
+	for _, err := range typecheckErrors {
+		t.Error(err)
+	}
+	if err != nil && len(typecheckErrors) == 0 {
+		// Only report errors when no type errors are found (an
+		// unexpected condition).
+		t.Error(err)
+	}
+	if t.Failed() {
+		return
+	}
+
+	// Configure the compiler.
+	config := compileopts.Config{
+		Options: &compileopts.Options{},
+		Target: &compileopts.TargetSpec{
+			Triple:    "armv7m-none-eabi",
+			BuildTags: []string{"cortexm", "baremetal", "linux", "arm"},
+			Scheduler: "tasks",
+		},
+	}
+	machine, err := NewTargetMachine(&config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	c := newCompilerContext("main", machine, &config)
+	c.runtimePkg = types.NewPackage("runtime", "runtime")
+	c.taskPkg = types.NewPackage("internal/task", "task")
+	irbuilder := c.ctx.NewBuilder()
+	defer irbuilder.Dispose()
+
+	// Create LLVM IR from the Go SSA.
+	c.createPackage(pkg, irbuilder)
+
+	// Check the IR with the LLVM verifier.
+	if err := llvm.VerifyModule(c.mod, llvm.PrintMessageAction); err != nil {
+		t.Error("verification error after IR construction")
+	}
+
+	// Check the IR with our own verifier (which checks for different things).
+	errs := ircheck.Module(c.mod)
+	for _, err := range errs {
+		t.Error(err)
+	}
+
+	// Check whether the IR matches the expected IR.
+	ir := c.mod.String()
+	ir = ir[strings.Index(ir, "\ntarget datalayout = ")+1:]
+	outfile := filepath.Join("testdata", name+".ll")
+	if *flagUpdate {
+		err := ioutil.WriteFile(outfile, []byte(ir), 0666)
+		if err != nil {
+			t.Error("could not read output file:", err)
+		}
+	} else {
+		ir2, err := ioutil.ReadFile(outfile)
+		if err != nil {
+			t.Fatal("could not read input file:", err)
+		}
+		ir2 = bytes.Replace(ir2, []byte("\r\n"), []byte("\n"), -1)
+		if ir != string(ir2) {
+			t.Error("output did not match")
+		}
+	}
+}
+
+// simpleImporter implements the types.Importer interface, but only allows
+// importing the unsafe package.
+type simpleImporter struct {
+}
+
+// Import implements the Importer interface. For testing usage only: it only
+// supports importing the unsafe package.
+func (i simpleImporter) Import(path string) (*types.Package, error) {
+	switch path {
+	case "unsafe":
+		return types.Unsafe, nil
+	default:
+		return nil, fmt.Errorf("importer not implemented for package %s", path)
 	}
-	return out
 }
@@ -14,8 +14,6 @@ package compiler
 //     frames.

 import (
-	"go/types"
-
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
@@ -29,8 +27,6 @@ func (b *builder) deferInitFunc() {
 	b.deferFuncs = make(map[*ssa.Function]int)
 	b.deferInvokeFuncs = make(map[string]int)
 	b.deferClosureFuncs = make(map[*ssa.Function]int)
-	b.deferExprFuncs = make(map[ssa.Value]int)
-	b.deferBuiltinFuncs = make(map[ssa.Value]deferBuiltin)

 	// Create defer list pointer.
 	deferType := llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)
@@ -107,6 +103,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {

 	} else if callee, ok := instr.Call.Value.(*ssa.Function); ok {
 		// Regular function call.
+
 		if _, ok := b.deferFuncs[callee]; !ok {
 			b.deferFuncs[callee] = len(b.allDeferFuncs)
 			b.allDeferFuncs = append(b.allDeferFuncs, callee)
@@ -152,53 +149,9 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		values = append(values, context)
 		valueTypes = append(valueTypes, context.Type())

-	} else if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
-		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{
-				callName: builtin.Name(),
-				pos:      builtin.Pos(),
-				argTypes: argTypes,
-				callback: len(b.allDeferFuncs),
-			}
-			b.allDeferFuncs = append(b.allDeferFuncs, instr.Call.Value)
-		}
-		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferBuiltinFuncs[instr.Call.Value].callback), false)
-
-		// Collect all values to be put in the struct (starting with
-		// runtime._defer fields).
-		values = []llvm.Value{callback, next}
-		for _, param := range argValues {
-			values = append(values, param)
-			valueTypes = append(valueTypes, param.Type())
-		}
-
 	} else {
-		funcValue := b.getValue(instr.Call.Value)
-
-		if _, ok := b.deferExprFuncs[instr.Call.Value]; !ok {
-			b.deferExprFuncs[instr.Call.Value] = len(b.allDeferFuncs)
-			b.allDeferFuncs = append(b.allDeferFuncs, &instr.Call)
-		}
-
-		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferExprFuncs[instr.Call.Value]), false)
-
-		// Collect all values to be put in the struct (starting with
-		// runtime._defer fields, followed by all parameters including the
-		// context pointer).
-		values = []llvm.Value{callback, next, funcValue}
-		valueTypes = append(valueTypes, funcValue.Type())
-		for _, param := range instr.Call.Args {
-			llvmParam := b.getValue(param)
-			values = append(values, llvmParam)
-			valueTypes = append(valueTypes, llvmParam.Type())
-		}
+		b.addError(instr.Pos(), "todo: defer on uncommon function call type")
+		return
 	}

 	// Make a struct out of the collected values to put in the defer frame.
@@ -217,11 +170,10 @@ 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)
-		nilPtr := llvm.ConstNull(b.i8ptrType)
-		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, nilPtr}, "defer.alloc.call")
+		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, "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)
@@ -289,23 +241,16 @@ func (b *builder) createRunDefers() {
 		b.SetInsertPointAtEnd(block)
 		switch callback := callback.(type) {
 		case *ssa.CallCommon:
-			// Call on an value or interface value.
-
-			// Get the real defer struct type and cast to it.
-			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
-
+			// Call on an interface value.
 			if !callback.IsInvoke() {
-				//Expect funcValue to be passed through the defer frame.
-				valueTypes = append(valueTypes, b.getFuncType(callback.Signature()))
-			} else {
-				//Expect typecode
-				valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
+				panic("expected an invoke call, not a direct call")
 			}

+			// Get the real defer struct type and cast to it.
+			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0), b.uintptrType, b.i8ptrType}
 			for _, arg := range callback.Args {
 				valueTypes = append(valueTypes, b.getLLVMType(arg.Type()))
 			}
-
 			deferFrameType := b.ctx.StructType(valueTypes, false)
 			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")

@@ -318,31 +263,18 @@ func (b *builder) createRunDefers() {
 				forwardParams = append(forwardParams, forwardParam)
 			}

-			var fnPtr llvm.Value
+			// Isolate the typecode.
+			typecode, forwardParams := forwardParams[0], forwardParams[1:]

-			if !callback.IsInvoke() {
-				// Isolate the func value.
-				funcValue := forwardParams[0]
-				forwardParams = forwardParams[1:]
+			// Add the context parameter. An interface call cannot also be a
+			// closure but we have to supply the parameter anyway for platforms
+			// with a strict calling convention.
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))

-				//Get function pointer and context
-				fp, context := b.decodeFuncValue(funcValue, callback.Signature())
-				fnPtr = fp
-
-				//Pass context
-				forwardParams = append(forwardParams, context)
-			} else {
-				// 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
-				// with a strict calling convention.
-				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
-			}
+			// Parent coroutine handle.
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))

+			fnPtr := b.getInvokePtr(callback, typecode)
 			b.createCall(fnPtr, forwardParams, "")

 		case *ssa.Function:
@@ -350,7 +282,7 @@ func (b *builder) createRunDefers() {

 			// Get the real defer struct type and cast to it.
 			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
-			for _, param := range getParams(callback.Signature) {
+			for _, param := range callback.Params {
 				valueTypes = append(valueTypes, b.getLLVMType(param.Type()))
 			}
 			deferFrameType := b.ctx.StructType(valueTypes, false)
@@ -359,7 +291,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 getParams(callback.Signature) {
+			for i := range callback.Params {
 				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)
@@ -371,6 +303,9 @@ func (b *builder) createRunDefers() {
 				// 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))
+
+				// Parent coroutine handle.
+				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 			}

 			// Call real function.
@@ -397,36 +332,12 @@ func (b *builder) createRunDefers() {
 				forwardParams = append(forwardParams, forwardParam)
 			}

+			// Parent coroutine handle.
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
+
 			// Call deferred function.
 			b.createCall(b.getFunction(fn), forwardParams, "")
-		case *ssa.Builtin:
-			db := b.deferBuiltinFuncs[callback]

-			//Get parameter types
-			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}
-
-			//Get signature from call results
-			params := callback.Type().Underlying().(*types.Signature).Params()
-			for i := 0; i < params.Len(); i++ {
-				valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
-			}
-
-			deferFrameType := b.ctx.StructType(valueTypes, false)
-			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
-
-			// Extract the params from the struct.
-			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")
-				argValues = append(argValues, forwardParam)
-			}
-
-			_, 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")
 		}
@@ -3,6 +3,7 @@ package compiler
 // This file contains some utility functions related to error handling.

 import (
+	"go/scanner"
 	"go/token"
 	"go/types"
 	"path/filepath"
@@ -19,11 +20,20 @@ func (c *compilerContext) makeError(pos token.Pos, msg string) types.Error {
 	}
 }

-// 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 {
@@ -5,7 +5,9 @@ package compiler

 import (
 	"go/types"
+	"strings"

+	"github.com/tinygo-org/tinygo/compileopts"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -19,8 +21,30 @@ func (b *builder) createFuncValue(funcPtr, context llvm.Value, sig *types.Signat
 // createFuncValue creates a function value from a raw function pointer with no
 // context.
 func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
-	// Closure is: {context, function pointer}
-	funcValueScalar := llvm.ConstBitCast(funcPtr, c.rawVoidFuncType)
+	var funcValueScalar llvm.Value
+	switch c.FuncImplementation() {
+	case compileopts.FuncValueDoubleword:
+		// Closure is: {context, function pointer}
+		funcValueScalar = funcPtr
+	case compileopts.FuncValueSwitch:
+		sigGlobal := c.getTypeCode(sig)
+		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,
+			})
+			funcValueWithSignatureGlobal = llvm.AddGlobal(c.mod, funcValueWithSignatureType, funcValueWithSignatureGlobalName)
+			funcValueWithSignatureGlobal.SetInitializer(funcValueWithSignature)
+			funcValueWithSignatureGlobal.SetGlobalConstant(true)
+			funcValueWithSignatureGlobal.SetLinkage(llvm.InternalLinkage)
+		}
+		funcValueScalar = llvm.ConstPtrToInt(funcValueWithSignatureGlobal, c.uintptrType)
+	default:
+		panic("unimplemented func value variant")
+	}
 	funcValueType := c.getFuncType(sig)
 	funcValue := llvm.Undef(funcValueType)
 	funcValue = builder.CreateInsertValue(funcValue, context, 0, "")
@@ -28,19 +52,6 @@ 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 {
@@ -57,19 +68,31 @@ 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, "")
-	bitcast := b.CreateExtractValue(funcValue, 1, "")
-	if !bitcast.IsAConstantExpr().IsNil() && bitcast.Opcode() == llvm.BitCast {
-		funcPtr = bitcast.Operand(0)
-		return
+	switch b.FuncImplementation() {
+	case compileopts.FuncValueDoubleword:
+		funcPtr = b.CreateExtractValue(funcValue, 1, "")
+	case compileopts.FuncValueSwitch:
+		llvmSig := b.getRawFuncType(sig)
+		sigGlobal := b.getTypeCode(sig)
+		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
+		funcPtr = b.CreateIntToPtr(funcPtr, llvmSig, "")
+	default:
+		panic("unimplemented func value variant")
 	}
-	llvmSig := b.getRawFuncType(sig)
-	funcPtr = b.CreateBitCast(bitcast, llvmSig, "")
 	return
 }

 // getFuncType returns the type of a func value given a signature.
 func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
-	return c.ctx.StructType([]llvm.Type{c.i8ptrType, c.rawVoidFuncType}, false)
+	switch c.FuncImplementation() {
+	case compileopts.FuncValueDoubleword:
+		rawPtr := c.getRawFuncType(typ)
+		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false)
+	case compileopts.FuncValueSwitch:
+		return c.getLLVMRuntimeType("funcValue")
+	default:
+		panic("unimplemented func value variant")
+	}
 }

 // getRawFuncType returns a LLVM function pointer type for a given signature.
@@ -103,18 +126,19 @@ 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 c.expandFormalParamType(recv, "", nil) {
+		for _, info := range 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 c.expandFormalParamType(subType, "", nil) {
+		for _, info := range expandFormalParamType(subType, "", nil) {
 			paramTypes = append(paramTypes, info.llvmType)
 		}
 	}
 	// All functions take these parameters at the end.
 	paramTypes = append(paramTypes, c.i8ptrType) // context
+	paramTypes = append(paramTypes, c.i8ptrType) // parent coroutine

 	// Make a func type out of the signature.
 	return llvm.PointerType(llvm.FunctionType(returnType, paramTypes, false), c.funcPtrAddrSpace)
@@ -127,6 +151,15 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 		panic("unexpected: MakeClosure without bound variables")
 	}
 	f := expr.Fn.(*ssa.Function)
+	llvmFn := b.getFunction(f)
+
+	if strings.HasSuffix(f.Name(), "$bound") && llvmFn.IsDeclaration() {
+		// Hack: the ssa package does not expose bound methods so make sure
+		// they're built here when necessary.
+		irbuilder := b.ctx.NewBuilder()
+		defer irbuilder.Dispose()
+		b.createFunction(irbuilder, f, llvmFn)
+	}

 	// Collect all bound variables.
 	boundVars := make([]llvm.Value, len(expr.Bindings))
@@ -141,5 +174,5 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	context := b.emitPointerPack(boundVars)

 	// Create the closure.
-	return b.createFuncValue(b.getFunction(f), context, f.Signature), nil
+	return b.createFuncValue(llvmFn, context, f.Signature), nil
 }
@@ -5,116 +5,33 @@ 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"
 )

-// 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.
-		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, funcPtr)
-		hasContext = true
-		prefix = b.fn.RelString(nil)
-	}
-
+// 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 {
 	paramBundle := b.emitPointerPack(params)
-	var stackSize llvm.Value
-	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).
-		stackSizeFn := b.getFunction(b.program.ImportedPackage("internal/task").Members["getGoroutineStackSize"].(*ssa.Function))
-		stackSize = b.createCall(stackSizeFn, []llvm.Value{callee, 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.
-		if (b.Scheduler == "tasks" || b.Scheduler == "asyncify") && b.DefaultStackSize == 0 {
-			b.addError(instr.Pos(), "default stack size for goroutines is not set")
-		}
-		stackSize = llvm.ConstInt(b.uintptrType, b.DefaultStackSize, false)
+	var callee llvm.Value
+	switch b.Scheduler() {
+	case "none", "tasks":
+		callee = b.createGoroutineStartWrapper(funcPtr, prefix, pos)
+	case "coroutines":
+		callee = b.CreatePtrToInt(funcPtr, b.uintptrType, "")
+	default:
+		panic("unreachable")
 	}
 	start := b.getFunction(b.program.ImportedPackage("internal/task").Members["start"].(*ssa.Function))
-	b.createCall(start, []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType)}, "")
+	b.createCall(start, []llvm.Value{callee, paramBundle, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
+	return llvm.Undef(funcPtr.Type().ElementType().ReturnType())
 }

 // createGoroutineStartWrapper creates a wrapper for the task-based
@@ -135,22 +52,12 @@ func (b *builder) createGo(instr *ssa.Go) {
 // 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.
-//
-// 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 {
+func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, pos token.Pos) llvm.Value {
 	var wrapper llvm.Value

 	builder := c.ctx.NewBuilder()
 	defer builder.Dispose()

-	var deadlock llvm.Value
-	if c.Scheduler == "asyncify" {
-		deadlock = c.getFunction(c.program.ImportedPackage("runtime").Members["deadlock"].(*ssa.Function))
-	}
-
 	if !fn.IsAFunction().IsNil() {
 		// See whether this wrapper has already been created. If so, return it.
 		name := fn.Name()
@@ -162,14 +69,12 @@ 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)
-		c.addStandardAttributes(wrapper)
-		wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
+		wrapper.SetLinkage(llvm.PrivateLinkage)
 		wrapper.SetUnnamedAddr(true)
-		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", name))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		builder.SetInsertPointAtEnd(entry)

-		if c.Debug {
+		if c.Debug() {
 			pos := c.program.Fset.Position(pos)
 			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
 				File:       c.getDIFile(pos.Filename),
@@ -193,23 +98,12 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri

 		// Create the list of params for the call.
 		paramTypes := fn.Type().ElementType().ParamTypes()
-		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 := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes[:len(paramTypes)-1])
+		params = append(params, llvm.Undef(c.i8ptrType))

 		// Create the call.
 		builder.CreateCall(fn, params, "")

-		if c.Scheduler == "asyncify" {
-			builder.CreateCall(deadlock, []llvm.Value{
-				llvm.Undef(c.i8ptrType),
-			}, "")
-		}
-
 	} else {
 		// For a function pointer like this:
 		//
@@ -231,14 +125,12 @@ 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)
-		c.addStandardAttributes(wrapper)
-		wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
+		wrapper.SetLinkage(llvm.InternalLinkage)
 		wrapper.SetUnnamedAddr(true)
-		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", ""))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
 		builder.SetInsertPointAtEnd(entry)

-		if c.Debug {
+		if c.Debug() {
 			pos := c.program.Fset.Position(pos)
 			diFuncType := c.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
 				File:       c.getDIFile(pos.Filename),
@@ -262,31 +154,23 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri

 		// Get the list of parameters, with the extra parameters at the end.
 		paramTypes := fn.Type().ElementType().ParamTypes()
-		paramTypes = append(paramTypes, fn.Type()) // the last element is the function pointer
+		paramTypes[len(paramTypes)-1] = fn.Type() // the last element is the function pointer
 		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)

 		// Get the function pointer.
 		fnPtr := params[len(params)-1]
-		params = params[:len(params)-1]
+
+		// Ignore the last param, which isn't used anymore.
+		// TODO: avoid this extra "parent handle" parameter in most functions.
+		params[len(params)-1] = llvm.Undef(c.i8ptrType)

 		// Create the call.
 		builder.CreateCall(fnPtr, params, "")
-
-		if c.Scheduler == "asyncify" {
-			builder.CreateCall(deadlock, []llvm.Value{
-				llvm.Undef(c.i8ptrType),
-			}, "")
-		}
 	}

-	if c.Scheduler == "asyncify" {
-		// The goroutine was terminated via deadlock.
-		builder.CreateUnreachable()
-	} else {
-		// Finish the function. Every basic block must end in a terminator, and
-		// because goroutines never return a value we can simply return void.
-		builder.CreateRetVoid()
-	}
+	// Finish the function. Every basic block must end in a terminator, and
+	// because goroutines never return a value we can simply return void.
+	builder.CreateRetVoid()

 	// Return a ptrtoint of the wrapper, not the function itself.
 	return builder.CreatePtrToInt(wrapper, c.uintptrType, "")
@@ -24,7 +24,7 @@ func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
 	// Magic function: insert inline assembly instead of calling it.
 	fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{}, false)
 	asm := constant.StringVal(args[0].(*ssa.Const).Value)
-	target := llvm.InlineAsm(fnType, asm, "", true, false, 0, false)
+	target := llvm.InlineAsm(fnType, asm, "", true, false, 0)
 	return b.CreateCall(target, nil, ""), nil
 }

@@ -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]
@@ -116,7 +116,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 		outputType = b.ctx.VoidType()
 	}
 	fnType := llvm.FunctionType(outputType, argTypes, false)
-	target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0, false)
+	target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0)
 	result := b.CreateCall(target, args, "")
 	if hasOutput {
 		return result, nil
@@ -159,45 +159,7 @@ func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 	// marked as clobbered.
 	constraints += ",~{r1},~{r2},~{r3}"
 	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0, false)
-	return b.CreateCall(target, llvmArgs, ""), nil
-}
-
-// This is a compiler builtin which emits an inline SVCall instruction. It can
-// be one of:
-//
-//     func SVCall0(num uintptr) uintptr
-//     func SVCall1(num uintptr, a1 interface{}) uintptr
-//     func SVCall2(num uintptr, a1, a2 interface{}) uintptr
-//     func SVCall3(num uintptr, a1, a2, a3 interface{}) uintptr
-//     func SVCall4(num uintptr, a1, a2, a3, a4 interface{}) uintptr
-//
-// The num parameter must be a constant. All other parameters may be any scalar
-// value supported by LLVM inline assembly.
-// Same as emitSVCall but for AArch64
-func (b *builder) emitSV64Call(args []ssa.Value) (llvm.Value, error) {
-	num, _ := constant.Uint64Val(args[0].(*ssa.Const).Value)
-	llvmArgs := []llvm.Value{}
-	argTypes := []llvm.Type{}
-	asm := "svc #" + strconv.FormatUint(num, 10)
-	constraints := "={x0}"
-	for i, arg := range args[1:] {
-		arg = arg.(*ssa.MakeInterface).X
-		if i == 0 {
-			constraints += ",0"
-		} else {
-			constraints += ",{x" + strconv.Itoa(i) + "}"
-		}
-		llvmValue := b.getValue(arg)
-		llvmArgs = append(llvmArgs, llvmValue)
-		argTypes = append(argTypes, llvmValue.Type())
-	}
-	// Implement the ARM64 calling convention by marking x1-x7 as
-	// clobbered. x0 is used as an output register so doesn't have to be
-	// marked as clobbered.
-	constraints += ",~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7}"
-	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0, false)
+	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0)
 	return b.CreateCall(target, llvmArgs, ""), nil
 }

@@ -222,24 +184,24 @@ func (b *builder) emitCSROperation(call *ssa.CallCommon) (llvm.Value, error) {
 		// marked as such.
 		fnType := llvm.FunctionType(b.uintptrType, nil, false)
 		asm := fmt.Sprintf("csrr $0, %d", csr)
-		target := llvm.InlineAsm(fnType, asm, "=r", true, false, 0, false)
+		target := llvm.InlineAsm(fnType, asm, "=r", true, false, 0)
 		return b.CreateCall(target, nil, ""), nil
 	case "Set":
 		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrw %d, $0", csr)
-		target := llvm.InlineAsm(fnType, asm, "r", true, false, 0, false)
+		target := llvm.InlineAsm(fnType, asm, "r", true, false, 0)
 		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
 	case "SetBits":
 		// Note: it may be possible to optimize this to csrrsi in many cases.
 		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrrs $0, %d, $1", csr)
-		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0, false)
+		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0)
 		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
 	case "ClearBits":
 		// Note: it may be possible to optimize this to csrrci in many cases.
 		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrrc $0, %d, $1", csr)
-		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0, false)
+		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0)
 		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
 	default:
 		return llvm.Value{}, b.makeError(call.Pos(), "unknown CSR operation: "+name)
@@ -24,22 +24,22 @@ 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)
-	itfTypeCode := b.CreatePtrToInt(itfTypeCodeGlobal, b.uintptrType, "")
+	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, "")
 	itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
 	itf = b.CreateInsertValue(itf, itfTypeCode, 0, "")
 	itf = b.CreateInsertValue(itf, itfValue, 1, "")
 	return itf
 }

-// extractValueFromInterface extract the value from an interface value
-// (runtime._interface) under the assumption that it is of the type given in
-// llvmType. The behavior is undefied if the interface is nil or llvmType
-// doesn't match the underlying type of the interface.
-func (b *builder) extractValueFromInterface(itf llvm.Value, llvmType llvm.Type) llvm.Value {
-	valuePtr := b.CreateExtractValue(itf, 1, "typeassert.value.ptr")
-	return b.emitPointerUnpack(valuePtr, []llvm.Type{llvmType})[0]
-}
-
 // getTypeCode returns a reference to a type code.
 // It returns a pointer to an external global which should be replaced with the
 // real type in the interface lowering pass.
@@ -54,9 +54,6 @@ 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())
@@ -73,38 +70,18 @@ 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
@@ -126,8 +103,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(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(llvm.Int32Type(), 0, false),
+			llvm.ConstInt(llvm.Int32Type(), 0, false),
 		})
 		fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldName, []uint32{1})
 		if typ.Tag(i) != "" {
@@ -135,8 +112,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(c.ctx.Int32Type(), 0, false),
-				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+				llvm.ConstInt(llvm.Int32Type(), 0, false),
+				llvm.ConstInt(llvm.Int32Type(), 0, false),
 			})
 			fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldTag, []uint32{2})
 		}
@@ -209,11 +186,7 @@ func getTypeCodeName(t types.Type) string {
 	case *types.Interface:
 		methods := make([]string, t.NumMethods())
 		for i := 0; i < t.NumMethods(); i++ {
-			name := t.Method(i).Name()
-			if !token.IsExported(name) {
-				name = t.Method(i).Pkg().Path() + "." + name
-			}
-			methods[i] = name + ":" + getTypeCodeName(t.Method(i).Type())
+			methods[i] = getTypeCodeName(t.Method(i).Type())
 		}
 		return "interface:" + "{" + strings.Join(methods, ",") + "}"
 	case *types.Map:
@@ -279,6 +252,13 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 			// compiler error, so panic
 			panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
 		}
+		if isAnonymous(typ) && llvmFn.IsDeclaration() {
+			// Inline types may also have methods when they embed interface
+			// types with methods. Example: struct{ error }
+			irbuilder := c.ctx.NewBuilder()
+			defer irbuilder.Dispose()
+			c.createFunction(irbuilder, fn, llvmFn)
+		}
 		wrapper := c.getInterfaceInvokeWrapper(fn, llvmFn)
 		methodInfo := llvm.ConstNamedStruct(interfaceMethodInfoType, []llvm.Value{
 			signatureGlobal,
@@ -291,7 +271,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.LinkOnceODRLinkage)
+	global.SetLinkage(llvm.PrivateLinkage)
 	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
 }

@@ -322,37 +302,19 @@ 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.LinkOnceODRLinkage)
+	global.SetLinkage(llvm.PrivateLinkage)
 	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 {
-	globalName := c.getMethodSignatureName(method)
-	signatureGlobal := c.mod.NamedGlobal(globalName)
+	signature := methodSignature(method)
+	signatureGlobal := c.mod.NamedGlobal("func " + signature)
 	if signatureGlobal.IsNil() {
-		// 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 = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), "func "+signature)
 		signatureGlobal.SetGlobalConstant(true)
-		signatureGlobal.SetAlignment(1)
 	}
 	return signatureGlobal
 }
@@ -372,28 +334,21 @@ 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 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 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 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
-		fn := b.getInterfaceImplementsFunc(expr.AssertedType)
-		commaOk = b.CreateCall(fn, []llvm.Value{actualTypeNum}, "")
+		methodSet := b.getInterfaceMethodSet(expr.AssertedType)
+		commaOk = b.createRuntimeCall("interfaceImplements", []llvm.Value{actualTypeNum, methodSet}, "")

 	} 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")
 	}

@@ -425,7 +380,8 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	} else {
 		// Type assert on concrete type. Extract the underlying type from
 		// the interface (but only after checking it matches).
-		valueOk = b.extractValueFromInterface(itf, assertedType)
+		valuePtr := b.CreateExtractValue(itf, 1, "typeassert.value.ptr")
+		valueOk = b.emitPointerUnpack(valuePtr, []llvm.Type{assertedType})[0]
 	}
 	b.CreateBr(nextBlock)

@@ -447,52 +403,39 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	}
 }

-// 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))
+// 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),
 	}
-	return strings.Join(methods, "; ")
+	fn := b.createRuntimeCall("interfaceMethod", values, "invoke.func")
+	return b.CreateIntToPtr(fn, llvmFnType, "invoke.func.cast")
 }

-// 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))
-	}
-	return llvmFn
-}
+// 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

-// 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))
+	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))
 	}
-	return llvmFn
+	// 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 fnCast, args
 }

 // getInterfaceInvokeWrapper returns a wrapper for the given method so it can be
@@ -509,9 +452,9 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	}

 	// Get the expanded receiver type.
-	receiverType := c.getLLVMType(fn.Signature.Recv().Type())
+	receiverType := c.getLLVMType(fn.Params[0].Type())
 	var expandedReceiverType []llvm.Type
-	for _, info := range c.expandFormalParamType(receiverType, "", nil) {
+	for _, info := range expandFormalParamType(receiverType, "", nil) {
 		expandedReceiverType = append(expandedReceiverType, info.llvmType)
 	}

@@ -529,9 +472,11 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	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)
+	if llvmFn.LastParam().Name() == "parentHandle" {
+		wrapper.LastParam().SetName("parentHandle")
+	}

-	wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
+	wrapper.SetLinkage(llvm.InternalLinkage)
 	wrapper.SetUnnamedAddr(true)

 	// Create a new builder just to create this wrapper.
@@ -542,7 +487,7 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	defer b.Builder.Dispose()

 	// add debug info if needed
-	if c.Debug {
+	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{})
@@ -565,6 +510,18 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	return wrapper
 }

+// isAnonymous returns true if (and only if) this is an anonymous type: one that
+// is created inline. It can have methods if it embeds a type with methods.
+func isAnonymous(typ types.Type) bool {
+	if t, ok := typ.(*types.Pointer); ok {
+		typ = t.Elem()
+	}
+	if _, ok := typ.(*types.Named); !ok {
+		return true
+	}
+	return false
+}
+
 // methodSignature creates a readable version of a method signature (including
 // the function name, excluding the receiver name). This string is used
 // internally to match interfaces and to call the correct method on an
@@ -36,26 +36,26 @@ 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.program.ImportedPackage("runtime/interrupt").Type("handle").Type()
 	globalLLVMType := b.getLLVMType(globalType)
-	globalName := b.fn.Package().Pkg.Path() + "$interrupt" + strconv.FormatInt(id.Int64(), 10)
+	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")
+	}
 	global := llvm.AddGlobal(b.mod, globalLLVMType, globalName)
-	global.SetVisibility(llvm.HiddenVisibility)
+	global.SetLinkage(llvm.PrivateLinkage)
 	global.SetGlobalConstant(true)
 	global.SetUnnamedAddr(true)
 	initializer := llvm.ConstNull(globalLLVMType)
-	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})
+	initializer = llvm.ConstInsertValue(initializer, funcValue, []uint32{0})
+	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(b.intType, uint64(id.Int64()), true), []uint32{1, 0})
 	global.SetInitializer(initializer)

 	// Add debug info to the interrupt global.
-	if b.Debug {
+	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),
@@ -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)
@@ -48,57 +48,3 @@ 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
-}
@@ -1,11 +1,6 @@
 package compiler

 import (
-	"fmt"
-	"go/token"
-	"go/types"
-	"math/big"
-
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"tinygo.org/x/go-llvm"
 )
@@ -13,6 +8,21 @@ 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.
@@ -34,7 +44,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.pkg.Path(), b.NeedsStackObjects, values)
+	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.Config, values)
 }

 // emitPointerUnpack extracts a list of values packed using emitPointerPack.
@@ -57,199 +67,3 @@ 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)
-	bitmap.FillBytes(bitmapBytes)
-	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")
-	}
-}
@@ -5,6 +5,7 @@ package llvmutil
 // itself if possible and legal.

 import (
+	"github.com/tinygo-org/tinygo/compileopts"
 	"tinygo.org/x/go-llvm"
 )

@@ -12,7 +13,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, prefix string, needsStackObjects bool, values []llvm.Value) llvm.Value {
+func EmitPointerPack(builder llvm.Builder, mod llvm.Module, config *compileopts.Config, values []llvm.Value) llvm.Value {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
 	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
@@ -25,6 +26,7 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needs
 	packedType := ctx.StructType(valueTypes, false)

 	// Allocate memory for the packed data.
+	var packedAlloc, packedHeapAlloc llvm.Value
 	size := targetData.TypeAllocSize(packedType)
 	if size == 0 {
 		return llvm.ConstPointerNull(i8ptrType)
@@ -37,39 +39,9 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needs
 			// Try to keep this cast in SSA form.
 			return builder.CreateIntToPtr(values[0], i8ptrType, "pack.int")
 		}
-
 		// Because packedType is a struct and we have to cast it to a *i8, store
-		// it in a *i8 alloca first and load the *i8 value from there. This is
-		// effectively a bitcast.
-		packedAlloc, _, _ := CreateTemporaryAlloca(builder, mod, i8ptrType, "")
-
-		if size < targetData.TypeAllocSize(i8ptrType) {
-			// The alloca is bigger than the value that will be stored in it.
-			// To avoid having some bits undefined, zero the alloca first.
-			// Hopefully this will get optimized away.
-			builder.CreateStore(llvm.ConstNull(i8ptrType), packedAlloc)
-		}
-
-		// Store all values in the alloca.
-		packedAllocCast := builder.CreateBitCast(packedAlloc, llvm.PointerType(packedType, 0), "")
-		for i, value := range values {
-			indices := []llvm.Value{
-				llvm.ConstInt(ctx.Int32Type(), 0, false),
-				llvm.ConstInt(ctx.Int32Type(), uint64(i), false),
-			}
-			gep := builder.CreateInBoundsGEP(packedAllocCast, indices, "")
-			builder.CreateStore(value, gep)
-		}
-
-		// Load value (the *i8) from the alloca.
-		result := builder.CreateLoad(packedAlloc, "")
-
-		// End the lifetime of the alloca, to help the optimizer.
-		packedPtr := builder.CreateBitCast(packedAlloc, i8ptrType, "")
-		packedSize := llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(packedAlloc.Type()), false)
-		EmitLifetimeEnd(builder, mod, packedPtr, packedSize)
-
-		return result
+		// it in an alloca first for bitcasting (store+bitcast+load).
+		packedAlloc, _, _ = CreateTemporaryAlloca(builder, mod, packedType, "")
 	} else {
 		// Check if the values are all constants.
 		constant := true
@@ -83,42 +55,53 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needs
 		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.
-			global := llvm.AddGlobal(mod, packedType, prefix+"$pack")
+			funcName := builder.GetInsertBlock().Parent().Name()
+			global := llvm.AddGlobal(mod, packedType, funcName+"$pack")
 			global.SetInitializer(ctx.ConstStruct(values, false))
 			global.SetGlobalConstant(true)
 			global.SetUnnamedAddr(true)
-			global.SetLinkage(llvm.InternalLinkage)
+			global.SetLinkage(llvm.PrivateLinkage)
 			return llvm.ConstBitCast(global, i8ptrType)
 		}

 		// Packed data is bigger than a pointer, so allocate it on the heap.
 		sizeValue := llvm.ConstInt(uintptrType, size, false)
 		alloc := mod.NamedFunction("runtime.alloc")
-		packedHeapAlloc := builder.CreateCall(alloc, []llvm.Value{
+		packedHeapAlloc = builder.CreateCall(alloc, []llvm.Value{
 			sizeValue,
-			llvm.ConstNull(i8ptrType),
-			llvm.Undef(i8ptrType), // unused context parameter
+			llvm.Undef(i8ptrType),            // unused context parameter
+			llvm.ConstPointerNull(i8ptrType), // coroutine handle
 		}, "")
-		if needsStackObjects {
+		if config.NeedsStackObjects() {
 			trackPointer := mod.NamedFunction("runtime.trackPointer")
 			builder.CreateCall(trackPointer, []llvm.Value{
 				packedHeapAlloc,
-				llvm.Undef(i8ptrType), // unused context parameter
+				llvm.Undef(i8ptrType),            // unused context parameter
+				llvm.ConstPointerNull(i8ptrType), // coroutine handle
 			}, "")
 		}
-		packedAlloc := builder.CreateBitCast(packedHeapAlloc, llvm.PointerType(packedType, 0), "")
-
-		// Store all values in the heap pointer.
-		for i, value := range values {
-			indices := []llvm.Value{
-				llvm.ConstInt(ctx.Int32Type(), 0, false),
-				llvm.ConstInt(ctx.Int32Type(), uint64(i), false),
-			}
-			gep := builder.CreateInBoundsGEP(packedAlloc, indices, "")
-			builder.CreateStore(value, gep)
+		packedAlloc = builder.CreateBitCast(packedHeapAlloc, llvm.PointerType(packedType, 0), "")
+	}
+	// Store all values in the alloca or heap pointer.
+	for i, value := range values {
+		indices := []llvm.Value{
+			llvm.ConstInt(ctx.Int32Type(), 0, false),
+			llvm.ConstInt(ctx.Int32Type(), uint64(i), false),
 		}
+		gep := builder.CreateInBoundsGEP(packedAlloc, indices, "")
+		builder.CreateStore(value, gep)
+	}

-		// Return the original heap allocation pointer, which already is an *i8.
+	if packedHeapAlloc.IsNil() {
+		// Load value (as *i8) from the alloca.
+		packedAlloc = builder.CreateBitCast(packedAlloc, llvm.PointerType(i8ptrType, 0), "")
+		result := builder.CreateLoad(packedAlloc, "")
+		packedPtr := builder.CreateBitCast(packedAlloc, i8ptrType, "")
+		packedSize := llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(packedAlloc.Type()), false)
+		EmitLifetimeEnd(builder, mod, packedPtr, packedSize)
+		return result
+	} else {
+		// Get the original heap allocation pointer, which already is an *i8.
 		return packedHeapAlloc
 	}
 }
@@ -167,66 +167,6 @@ func (b *builder) createMapDelete(keyType types.Type, m, key llvm.Value, pos tok
 	}
 }

-// createMapIteratorNext lowers the *ssa.Next instruction for iterating over a
-// map. It returns a tuple of {bool, key, value} with the result of the
-// iteration.
-func (b *builder) createMapIteratorNext(rangeVal ssa.Value, llvmRangeVal, it llvm.Value) llvm.Value {
-	// Determine the type of the values to return from the *ssa.Next
-	// instruction. It is returned as {bool, keyType, valueType}.
-	keyType := rangeVal.Type().Underlying().(*types.Map).Key()
-	valueType := rangeVal.Type().Underlying().(*types.Map).Elem()
-	llvmKeyType := b.getLLVMType(keyType)
-	llvmValueType := b.getLLVMType(valueType)
-
-	// There is a special case in which keys are stored as an interface value
-	// instead of the value they normally are. This happens for non-trivially
-	// comparable types such as float32 or some structs.
-	isKeyStoredAsInterface := false
-	if t, ok := keyType.Underlying().(*types.Basic); ok && t.Info()&types.IsString != 0 {
-		// key is a string
-	} else if hashmapIsBinaryKey(keyType) {
-		// key can be compared with runtime.memequal
-	} else {
-		// The key is stored as an interface value, and may or may not be an
-		// interface type (for example, float32 keys are stored as an interface
-		// value).
-		if _, ok := keyType.Underlying().(*types.Interface); !ok {
-			isKeyStoredAsInterface = true
-		}
-	}
-
-	// Determine the type of the key as stored in the map.
-	llvmStoredKeyType := llvmKeyType
-	if isKeyStoredAsInterface {
-		llvmStoredKeyType = b.getLLVMRuntimeType("_interface")
-	}
-
-	// Extract the key and value from the map.
-	mapKeyAlloca, mapKeyPtr, mapKeySize := b.createTemporaryAlloca(llvmStoredKeyType, "range.key")
-	mapValueAlloca, mapValuePtr, mapValueSize := b.createTemporaryAlloca(llvmValueType, "range.value")
-	ok := b.createRuntimeCall("hashmapNext", []llvm.Value{llvmRangeVal, it, mapKeyPtr, mapValuePtr}, "range.next")
-	mapKey := b.CreateLoad(mapKeyAlloca, "")
-	mapValue := b.CreateLoad(mapValueAlloca, "")
-
-	if isKeyStoredAsInterface {
-		// The key is stored as an interface but it isn't of interface type.
-		// Extract the underlying value.
-		mapKey = b.extractValueFromInterface(mapKey, llvmKeyType)
-	}
-
-	// End the lifetimes of the allocas, because we're done with them.
-	b.emitLifetimeEnd(mapKeyPtr, mapKeySize)
-	b.emitLifetimeEnd(mapValuePtr, mapValueSize)
-
-	// Construct the *ssa.Next return value: {ok, mapKey, mapValue}
-	tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{b.ctx.Int1Type(), llvmKeyType, llvmValueType}, false))
-	tuple = b.CreateInsertValue(tuple, ok, 0, "")
-	tuple = b.CreateInsertValue(tuple, mapKey, 1, "")
-	tuple = b.CreateInsertValue(tuple, mapValue, 2, "")
-
-	return tuple
-}
-
 // Returns true if this key type does not contain strings, interfaces etc., so
 // can be compared with runtime.memequal.
 func hashmapIsBinaryKey(keyType types.Type) bool {
@@ -0,0 +1,344 @@
+// +build none
+
+// This file generates runtimetypes.go from the AST of the TinyGo runtime
+// package. This type information is necessary to avoid having to compile the
+// runtime to compile any package.
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/token"
+	"io"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// The list of runtime types known by the compiler.
+var runtimeTypes = []string{
+	// panic, recover
+	"_defer",
+	// strings
+	"_string", "stringIterator",
+	// map
+	"hashmap", "hashmapBucket", "hashmapIterator",
+	// channel
+	"channel", "channelBlockedList", "chanSelectState",
+	// interface
+	"_interface", "interfaceMethodInfo", "typecodeID", "structField", "typeInInterface",
+	// func
+	"funcValue", "funcValueWithSignature",
+}
+
+// The list of runtime calls known to the compiler.
+var runtimeCalls = []string{
+	// panic, recover
+	"_panic", "_recover",
+	"nilPanic", "lookupPanic", "slicePanic", "chanMakePanic", "negativeShiftPanic",
+	// string
+	"stringEqual", "stringLess",
+	"stringConcat",
+	"stringFromBytes", "stringToBytes",
+	"stringFromRunes", "stringToRunes",
+	"stringFromUnicode",
+	"stringNext",
+	// complex
+	"complex64div", "complex128div",
+	// slice
+	"sliceAppend", "sliceCopy",
+	// memory
+	"alloc", "trackPointer",
+	// print builtin
+	"printbool",
+	"printint8", "printuint8",
+	"printint16", "printuint16",
+	"printint32", "printuint32",
+	"printint64", "printuint64",
+	"printfloat32", "printfloat64",
+	"printcomplex64", "printcomplex128",
+	"printstring", "printspace", "printnl",
+	"printptr", "printmap", "printitf",
+	// hashmap
+	"hashmapMake", "hashmapLen", "hashmapNext",
+	"hashmapStringGet", "hashmapStringSet", "hashmapStringDelete",
+	"hashmapInterfaceGet", "hashmapInterfaceSet", "hashmapInterfaceDelete",
+	"hashmapBinaryGet", "hashmapBinarySet", "hashmapBinaryDelete",
+	// channel, concurrency
+	"tryChanSelect", "chanMake", "chanSend", "chanRecv", "chanClose", "chanSelect",
+	"deadlock",
+	// interface, reflect
+	"interfaceEqual", "interfaceImplements", "interfaceMethod",
+	"typeAssert", "interfaceTypeAssert",
+	// func
+	"getFuncPtr",
+}
+
+// makeDefs generates runtimetypes.go and writes it out after formatting it.
+func makeDefs() error {
+	// Load the runtime package.
+	pkgs, err := packages.Load(&packages.Config{
+		Mode:       packages.NeedSyntax,
+		BuildFlags: []string{"-tags=gc.extalloc"},
+	}, "../src/runtime")
+	if err != nil {
+		return err
+	}
+	if len(pkgs) != 1 {
+		return fmt.Errorf("expected 1 package, got %d", len(pkgs))
+	}
+	runtimePkg := pkgs[0]
+	if len(runtimePkg.Errors) != 0 {
+		return runtimePkg.Errors[0]
+	}
+
+	// Start creating the new Go file.
+	buf := &bytes.Buffer{}
+	buf.WriteString(`// Autogenerated by mkruntimetypes.go, DO NOT EDIT.
+
+package compiler
+
+// This file contains definitions for runtime types and functions, so that the
+// runtime package can be compiled independently of other packages.
+
+import (
+	"go/token"
+	"go/types"
+	"strconv"
+)
+
+// getRuntimeType constructs a new runtime type with the given name. The types
+// constructed here must match the types in the runtime package.
+func (c *compilerContext) getRuntimeType(name string) types.Type {
+	if c.program != nil {
+		return c.program.ImportedPackage("runtime").Type(name).Type()
+	}
+	if typ, ok := c.runtimeTypes[name]; ok {
+		// This type was already created.
+		return typ
+	}
+
+	typeName := types.NewTypeName(token.NoPos, c.runtimePkg, name, nil)
+	named := types.NewNamed(typeName, nil, nil)
+
+	// Make sure recursive types are only defined once.
+	c.runtimeTypes[name] = named
+
+	var fieldTypes []types.Type
+	switch name {
+`)
+	err = makeTypeDefs(buf, runtimePkg)
+	if err != nil {
+		return err
+	}
+	buf.WriteString(`		default:
+		panic("could not find runtime type: runtime." + name)
+	}
+
+	// Create the named struct type.
+	var fields []*types.Var
+	for i, t := range fieldTypes {
+		// Field name doesn't matter: this type is only used to create a LLVM
+		// struct type which don't have field names.
+		fields = append(fields, types.NewField(token.NoPos, nil, "field"+strconv.Itoa(i), t, false))
+	}
+	named.SetUnderlying(types.NewStruct(fields, nil))
+	return named
+}
+
+// getRuntimeFuncType constructs a new runtime function signature with the given
+// name. The function signatures constructed here must match the functions in
+// the runtime package.
+func (c *compilerContext) getRuntimeFuncType(name string) *types.Signature {
+	var params []*types.Var
+	addParam := func(name string, typ types.Type) {
+		params = append(params, types.NewParam(token.NoPos, c.runtimePkg, name, typ))
+	}
+	var results []*types.Var
+	addResult := func(typ types.Type) {
+		results = append(results, types.NewParam(token.NoPos, c.runtimePkg, "", typ))
+	}
+	switch name {
+`)
+
+	err = makeFuncDefs(buf, runtimePkg)
+	if err != nil {
+		return err
+	}
+	buf.WriteString(`	default:
+		panic("unknown runtime call: runtime." + name)
+	}
+	return types.NewSignature(nil, types.NewTuple(params...), types.NewTuple(results...), false)
+}
+`)
+
+	source, err := format.Source(buf.Bytes())
+	if err != nil {
+		// Fallback (useful for investigating errors).
+		source = buf.Bytes()
+	}
+	err2 := ioutil.WriteFile("runtimetypes.go", source, 0666)
+	if err2 != nil {
+		return err2 // error from ioutil.WriteFile
+	}
+	return err // error from format.Source (if any)
+}
+
+// makeTypeDefs generates the switch body of the getRuntimeType function.
+func makeTypeDefs(w io.Writer, runtimePkg *packages.Package) error {
+	typeSpecs := map[string]*ast.TypeSpec{}
+	for _, file := range runtimePkg.Syntax {
+		for _, decl := range file.Decls {
+			switch decl := decl.(type) {
+			case *ast.GenDecl:
+				if decl.Tok != token.TYPE {
+					continue
+				}
+				for _, spec := range decl.Specs {
+					typeSpec := spec.(*ast.TypeSpec)
+					typeSpecs[typeSpec.Name.Name] = typeSpec
+				}
+			}
+		}
+	}
+
+	for _, name := range runtimeTypes {
+		typeSpec := typeSpecs[name]
+		if typeSpec == nil {
+			return fmt.Errorf("could not find type: %s", name)
+		}
+		fmt.Fprintf(w, "\tcase %#v:\n", typeSpec.Name.Name)
+		if name == "channelBlockedList" {
+			fmt.Fprintf(w, "\t\ttaskType := types.NewNamed(types.NewTypeName(token.NoPos, c.taskPkg, \"Task\", nil), nil, nil)\n")
+		}
+		fmt.Fprintf(w, "\t\tfieldTypes = []types.Type{\n")
+		for _, field := range typeSpec.Type.(*ast.StructType).Fields.List {
+			fieldType := getTypeFromExpr(field.Type, typeSpec.Name.Name)
+			for _, ident := range field.Names {
+				fmt.Fprintf(w, "\t\t\t%s, // %s\n", fieldType, ident.Name)
+			}
+		}
+		fmt.Fprintf(w, "\t\t}\n")
+	}
+	return nil
+}
+
+// makeFuncDefs generates the switch body of the getRuntimeFuncType function.
+func makeFuncDefs(w io.Writer, runtimePkg *packages.Package) error {
+	functions := map[string]*ast.FuncDecl{}
+	for _, file := range runtimePkg.Syntax {
+		for _, decl := range file.Decls {
+			switch decl := decl.(type) {
+			case *ast.FuncDecl:
+				functions[decl.Name.Name] = decl
+			default:
+			}
+		}
+	}
+
+	for _, name := range runtimeCalls {
+		decl := functions[name]
+		if decl == nil {
+			return fmt.Errorf("could not find function: %s", name)
+		}
+		fmt.Fprintf(w, "\tcase %#v:\n", decl.Name.Name)
+		for _, field := range decl.Type.Params.List {
+			typeString := getTypeFromExpr(field.Type, "")
+			for _, name := range field.Names {
+				fmt.Fprintf(w, "\t\taddParam(%#v, %s)\n", name.Name, typeString)
+			}
+		}
+		if decl.Type.Results != nil {
+			for _, field := range decl.Type.Results.List {
+				typeString := getTypeFromExpr(field.Type, "")
+				for range field.Names {
+					fmt.Fprintf(w, "\t\taddResult(%s)\n", typeString)
+				}
+				if len(field.Names) == 0 {
+					fmt.Fprintf(w, "\t\taddResult(%s)\n", typeString)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// getTypeFromExpr returns a string which is a piece of Go code that constructs
+// the type (as given in ast.Expr) using the go/types package.
+func getTypeFromExpr(typ ast.Expr, currentTypeName string) string {
+	switch typ := typ.(type) {
+	case *ast.Ident:
+		if typ.Name == currentTypeName {
+			// Assume a global named "named" which refers to the currently
+			// created named type.
+			return "named"
+		}
+		switch typ.Name {
+		case "bool", "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr", "float32", "float64", "complex64", "complex128", "string", "byte", "rune":
+			// Built-in types.
+			return fmt.Sprintf("types.Typ[types.%s]", strings.Title(typ.Name))
+		case "chanState":
+			// runtime.chanState is a named type, but that doesn't matter when
+			// generating LLVM IR.
+			return fmt.Sprintf("types.Typ[types.Uint8]")
+		default:
+			// Assume that we can simply get the type recursively.
+			return fmt.Sprintf("c.getRuntimeType(%#v)", typ.Name)
+		}
+	case *ast.StarExpr:
+		return fmt.Sprintf("types.NewPointer(%s)", getTypeFromExpr(typ.X, currentTypeName))
+	case *ast.InterfaceType:
+		if len(typ.Methods.List) != 0 {
+			// Unimplemented: interfaces with methods.
+			return "interface{?}"
+		}
+		return "types.NewInterfaceType(nil, nil)"
+	case *ast.ArrayType:
+		// Slices and arrays. Assume the array length is a numeric constant and
+		// not a Go named constant for example.
+		elementType := getTypeFromExpr(typ.Elt, currentTypeName)
+		if typ.Len == nil {
+			return fmt.Sprintf("types.NewSlice(%s)", elementType)
+		}
+		length := typ.Len.(*ast.BasicLit).Value
+		return fmt.Sprintf("types.NewArray(%s, %s)", elementType, length)
+	case *ast.SelectorExpr:
+		s := typ.X.(*ast.Ident).Name + "." + typ.Sel.Name
+		switch s {
+		case "unsafe.Pointer":
+			return "types.Typ[types.UnsafePointer]"
+		case "task.Task":
+			// Assume there is a variable taskType which refers to the task.Task
+			// structure.
+			return "taskType"
+		default:
+			return fmt.Sprintf("<unknown %s>", s)
+		}
+	case *ast.StructType:
+		// Inline struct type.
+		var fields string
+		for _, field := range typ.Fields.List {
+			fieldType := getTypeFromExpr(field.Type, currentTypeName)
+			for _, ident := range field.Names {
+				fields += fmt.Sprintf("\t\t\ttypes.NewField(token.NoPos, nil, %#v, %s, false),\n", ident.Name, fieldType)
+			}
+		}
+		return fmt.Sprintf("types.NewStruct([]*types.Var{\n%s\t\t}, nil)", fields)
+	default:
+		// Dump the raw typ value, for debugging.
+		return fmt.Sprintf("%#v", typ)
+	}
+}
+
+func main() {
+	err := makeDefs()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "could not create defs:", err)
+		os.Exit(1)
+	}
+}
@@ -0,0 +1,377 @@
+// Autogenerated by mkruntimetypes.go, DO NOT EDIT.
+
+package compiler
+
+// This file contains definitions for runtime types and functions, so that the
+// runtime package can be compiled independently of other packages.
+
+import (
+	"go/token"
+	"go/types"
+	"strconv"
+)
+
+// getRuntimeType constructs a new runtime type with the given name. The types
+// constructed here must match the types in the runtime package.
+func (c *compilerContext) getRuntimeType(name string) types.Type {
+	if c.program != nil {
+		return c.program.ImportedPackage("runtime").Type(name).Type()
+	}
+	if typ, ok := c.runtimeTypes[name]; ok {
+		// This type was already created.
+		return typ
+	}
+
+	typeName := types.NewTypeName(token.NoPos, c.runtimePkg, name, nil)
+	named := types.NewNamed(typeName, nil, nil)
+
+	// Make sure recursive types are only defined once.
+	c.runtimeTypes[name] = named
+
+	var fieldTypes []types.Type
+	switch name {
+	case "_defer":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr], // callback
+			types.NewPointer(named),  // next
+		}
+	case "_string":
+		fieldTypes = []types.Type{
+			types.NewPointer(types.Typ[types.Byte]), // ptr
+			types.Typ[types.Uintptr],                // length
+		}
+	case "stringIterator":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr], // byteindex
+		}
+	case "hashmap":
+		fieldTypes = []types.Type{
+			types.NewPointer(named),        // next
+			types.Typ[types.UnsafePointer], // buckets
+			types.Typ[types.Uintptr],       // count
+			types.Typ[types.Uint8],         // keySize
+			types.Typ[types.Uint8],         // valueSize
+			types.Typ[types.Uint8],         // bucketBits
+		}
+	case "hashmapBucket":
+		fieldTypes = []types.Type{
+			types.NewArray(types.Typ[types.Uint8], 8), // tophash
+			types.NewPointer(named),                   // next
+		}
+	case "hashmapIterator":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr],                            // bucketNumber
+			types.NewPointer(c.getRuntimeType("hashmapBucket")), // bucket
+			types.Typ[types.Uint8],                              // bucketIndex
+		}
+	case "channel":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr],                                 // elementSize
+			types.Typ[types.Uintptr],                                 // bufSize
+			types.Typ[types.Uint8],                                   // state
+			types.NewPointer(c.getRuntimeType("channelBlockedList")), // blocked
+			types.Typ[types.Uintptr],                                 // bufHead
+			types.Typ[types.Uintptr],                                 // bufTail
+			types.Typ[types.Uintptr],                                 // bufUsed
+			types.Typ[types.UnsafePointer],                           // buf
+		}
+	case "channelBlockedList":
+		taskType := types.NewNamed(types.NewTypeName(token.NoPos, c.taskPkg, "Task", nil), nil, nil)
+		fieldTypes = []types.Type{
+			types.NewPointer(named),                               // next
+			types.NewPointer(taskType),                            // t
+			types.NewPointer(c.getRuntimeType("chanSelectState")), // s
+			types.NewSlice(named),                                 // allSelectOps
+		}
+	case "chanSelectState":
+		fieldTypes = []types.Type{
+			types.NewPointer(c.getRuntimeType("channel")), // ch
+			types.Typ[types.UnsafePointer],                // value
+		}
+	case "_interface":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr],       // typecode
+			types.Typ[types.UnsafePointer], // value
+		}
+	case "interfaceMethodInfo":
+		fieldTypes = []types.Type{
+			types.NewPointer(types.Typ[types.Uint8]), // signature
+			types.Typ[types.Uintptr],                 // funcptr
+		}
+	case "typecodeID":
+		fieldTypes = []types.Type{
+			types.NewPointer(named),  // references
+			types.Typ[types.Uintptr], // length
+		}
+	case "structField":
+		fieldTypes = []types.Type{
+			types.NewPointer(c.getRuntimeType("typecodeID")), // typecode
+			types.NewPointer(types.Typ[types.Uint8]),         // name
+			types.NewPointer(types.Typ[types.Uint8]),         // tag
+			types.Typ[types.Bool],                            // embedded
+		}
+	case "typeInInterface":
+		fieldTypes = []types.Type{
+			types.NewPointer(c.getRuntimeType("typecodeID")),          // typecode
+			types.NewPointer(c.getRuntimeType("interfaceMethodInfo")), // methodSet
+		}
+	case "funcValue":
+		fieldTypes = []types.Type{
+			types.Typ[types.UnsafePointer], // context
+			types.Typ[types.Uintptr],       // id
+		}
+	case "funcValueWithSignature":
+		fieldTypes = []types.Type{
+			types.Typ[types.Uintptr],                         // funcPtr
+			types.NewPointer(c.getRuntimeType("typecodeID")), // signature
+		}
+	default:
+		panic("could not find runtime type: runtime." + name)
+	}
+
+	// Create the named struct type.
+	var fields []*types.Var
+	for i, t := range fieldTypes {
+		// Field name doesn't matter: this type is only used to create a LLVM
+		// struct type which don't have field names.
+		fields = append(fields, types.NewField(token.NoPos, nil, "field"+strconv.Itoa(i), t, false))
+	}
+	named.SetUnderlying(types.NewStruct(fields, nil))
+	return named
+}
+
+// getRuntimeFuncType constructs a new runtime function signature with the given
+// name. The function signatures constructed here must match the functions in
+// the runtime package.
+func (c *compilerContext) getRuntimeFuncType(name string) *types.Signature {
+	var params []*types.Var
+	addParam := func(name string, typ types.Type) {
+		params = append(params, types.NewParam(token.NoPos, c.runtimePkg, name, typ))
+	}
+	var results []*types.Var
+	addResult := func(typ types.Type) {
+		results = append(results, types.NewParam(token.NoPos, c.runtimePkg, "", typ))
+	}
+	switch name {
+	case "_panic":
+		addParam("message", types.NewInterfaceType(nil, nil))
+	case "_recover":
+		addResult(types.NewInterfaceType(nil, nil))
+	case "nilPanic":
+	case "lookupPanic":
+	case "slicePanic":
+	case "chanMakePanic":
+	case "negativeShiftPanic":
+	case "stringEqual":
+		addParam("x", types.Typ[types.String])
+		addParam("y", types.Typ[types.String])
+		addResult(types.Typ[types.Bool])
+	case "stringLess":
+		addParam("x", types.Typ[types.String])
+		addParam("y", types.Typ[types.String])
+		addResult(types.Typ[types.Bool])
+	case "stringConcat":
+		addParam("x", c.getRuntimeType("_string"))
+		addParam("y", c.getRuntimeType("_string"))
+		addResult(c.getRuntimeType("_string"))
+	case "stringFromBytes":
+		addParam("x", types.NewStruct([]*types.Var{
+			types.NewField(token.NoPos, nil, "ptr", types.NewPointer(types.Typ[types.Byte]), false),
+			types.NewField(token.NoPos, nil, "len", types.Typ[types.Uintptr], false),
+			types.NewField(token.NoPos, nil, "cap", types.Typ[types.Uintptr], false),
+		}, nil))
+		addResult(c.getRuntimeType("_string"))
+	case "stringToBytes":
+		addParam("x", c.getRuntimeType("_string"))
+		addResult(types.NewStruct([]*types.Var{
+			types.NewField(token.NoPos, nil, "ptr", types.NewPointer(types.Typ[types.Byte]), false),
+			types.NewField(token.NoPos, nil, "len", types.Typ[types.Uintptr], false),
+			types.NewField(token.NoPos, nil, "cap", types.Typ[types.Uintptr], false),
+		}, nil))
+	case "stringFromRunes":
+		addParam("runeSlice", types.NewSlice(types.Typ[types.Rune]))
+		addResult(c.getRuntimeType("_string"))
+	case "stringToRunes":
+		addParam("s", types.Typ[types.String])
+		addResult(types.NewSlice(types.Typ[types.Rune]))
+	case "stringFromUnicode":
+		addParam("x", types.Typ[types.Rune])
+		addResult(c.getRuntimeType("_string"))
+	case "stringNext":
+		addParam("s", types.Typ[types.String])
+		addParam("it", types.NewPointer(c.getRuntimeType("stringIterator")))
+		addResult(types.Typ[types.Bool])
+		addResult(types.Typ[types.Int])
+		addResult(types.Typ[types.Rune])
+	case "complex64div":
+		addParam("n", types.Typ[types.Complex64])
+		addParam("m", types.Typ[types.Complex64])
+		addResult(types.Typ[types.Complex64])
+	case "complex128div":
+		addParam("n", types.Typ[types.Complex128])
+		addParam("m", types.Typ[types.Complex128])
+		addResult(types.Typ[types.Complex128])
+	case "sliceAppend":
+		addParam("srcBuf", types.Typ[types.UnsafePointer])
+		addParam("elemsBuf", types.Typ[types.UnsafePointer])
+		addParam("srcLen", types.Typ[types.Uintptr])
+		addParam("srcCap", types.Typ[types.Uintptr])
+		addParam("elemsLen", types.Typ[types.Uintptr])
+		addParam("elemSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.UnsafePointer])
+		addResult(types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Uintptr])
+	case "sliceCopy":
+		addParam("dst", types.Typ[types.UnsafePointer])
+		addParam("src", types.Typ[types.UnsafePointer])
+		addParam("dstLen", types.Typ[types.Uintptr])
+		addParam("srcLen", types.Typ[types.Uintptr])
+		addParam("elemSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Int])
+	case "alloc":
+		addParam("size", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.UnsafePointer])
+	case "trackPointer":
+		addParam("ptr", types.Typ[types.UnsafePointer])
+	case "printbool":
+		addParam("b", types.Typ[types.Bool])
+	case "printint8":
+		addParam("n", types.Typ[types.Int8])
+	case "printuint8":
+		addParam("n", types.Typ[types.Uint8])
+	case "printint16":
+		addParam("n", types.Typ[types.Int16])
+	case "printuint16":
+		addParam("n", types.Typ[types.Uint16])
+	case "printint32":
+		addParam("n", types.Typ[types.Int32])
+	case "printuint32":
+		addParam("n", types.Typ[types.Uint32])
+	case "printint64":
+		addParam("n", types.Typ[types.Int64])
+	case "printuint64":
+		addParam("n", types.Typ[types.Uint64])
+	case "printfloat32":
+		addParam("v", types.Typ[types.Float32])
+	case "printfloat64":
+		addParam("v", types.Typ[types.Float64])
+	case "printcomplex64":
+		addParam("c", types.Typ[types.Complex64])
+	case "printcomplex128":
+		addParam("c", types.Typ[types.Complex128])
+	case "printstring":
+		addParam("s", types.Typ[types.String])
+	case "printspace":
+	case "printnl":
+	case "printptr":
+		addParam("ptr", types.Typ[types.Uintptr])
+	case "printmap":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+	case "printitf":
+		addParam("msg", types.NewInterfaceType(nil, nil))
+	case "hashmapMake":
+		addParam("keySize", types.Typ[types.Uint8])
+		addParam("valueSize", types.Typ[types.Uint8])
+		addParam("sizeHint", types.Typ[types.Uintptr])
+		addResult(types.NewPointer(c.getRuntimeType("hashmap")))
+	case "hashmapLen":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addResult(types.Typ[types.Int])
+	case "hashmapNext":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("it", types.NewPointer(c.getRuntimeType("hashmapIterator")))
+		addParam("key", types.Typ[types.UnsafePointer])
+		addParam("value", types.Typ[types.UnsafePointer])
+		addResult(types.Typ[types.Bool])
+	case "hashmapStringGet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.String])
+		addParam("value", types.Typ[types.UnsafePointer])
+		addParam("valueSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "hashmapStringSet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.String])
+		addParam("value", types.Typ[types.UnsafePointer])
+	case "hashmapStringDelete":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.String])
+	case "hashmapInterfaceGet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.NewInterfaceType(nil, nil))
+		addParam("value", types.Typ[types.UnsafePointer])
+		addParam("valueSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "hashmapInterfaceSet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.NewInterfaceType(nil, nil))
+		addParam("value", types.Typ[types.UnsafePointer])
+	case "hashmapInterfaceDelete":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.NewInterfaceType(nil, nil))
+	case "hashmapBinaryGet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.UnsafePointer])
+		addParam("value", types.Typ[types.UnsafePointer])
+		addParam("valueSize", types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "hashmapBinarySet":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.UnsafePointer])
+		addParam("value", types.Typ[types.UnsafePointer])
+	case "hashmapBinaryDelete":
+		addParam("m", types.NewPointer(c.getRuntimeType("hashmap")))
+		addParam("key", types.Typ[types.UnsafePointer])
+	case "tryChanSelect":
+		addParam("recvbuf", types.Typ[types.UnsafePointer])
+		addParam("states", types.NewSlice(c.getRuntimeType("chanSelectState")))
+		addResult(types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "chanMake":
+		addParam("elementSize", types.Typ[types.Uintptr])
+		addParam("bufSize", types.Typ[types.Uintptr])
+		addResult(types.NewPointer(c.getRuntimeType("channel")))
+	case "chanSend":
+		addParam("ch", types.NewPointer(c.getRuntimeType("channel")))
+		addParam("value", types.Typ[types.UnsafePointer])
+	case "chanRecv":
+		addParam("ch", types.NewPointer(c.getRuntimeType("channel")))
+		addParam("value", types.Typ[types.UnsafePointer])
+		addResult(types.Typ[types.Bool])
+	case "chanClose":
+		addParam("ch", types.NewPointer(c.getRuntimeType("channel")))
+	case "chanSelect":
+		addParam("recvbuf", types.Typ[types.UnsafePointer])
+		addParam("states", types.NewSlice(c.getRuntimeType("chanSelectState")))
+		addParam("ops", types.NewSlice(c.getRuntimeType("channelBlockedList")))
+		addResult(types.Typ[types.Uintptr])
+		addResult(types.Typ[types.Bool])
+	case "deadlock":
+	case "interfaceEqual":
+		addParam("x", types.NewInterfaceType(nil, nil))
+		addParam("y", types.NewInterfaceType(nil, nil))
+		addResult(types.Typ[types.Bool])
+	case "interfaceImplements":
+		addParam("typecode", types.Typ[types.Uintptr])
+		addParam("interfaceMethodSet", types.NewPointer(types.NewPointer(types.Typ[types.Uint8])))
+		addResult(types.Typ[types.Bool])
+	case "interfaceMethod":
+		addParam("typecode", types.Typ[types.Uintptr])
+		addParam("interfaceMethodSet", types.NewPointer(types.NewPointer(types.Typ[types.Uint8])))
+		addParam("signature", types.NewPointer(types.Typ[types.Uint8]))
+		addResult(types.Typ[types.Uintptr])
+	case "typeAssert":
+		addParam("actualType", types.Typ[types.Uintptr])
+		addParam("assertedType", types.NewPointer(c.getRuntimeType("typecodeID")))
+		addResult(types.Typ[types.Bool])
+	case "interfaceTypeAssert":
+		addParam("ok", types.Typ[types.Bool])
+	case "getFuncPtr":
+		addParam("val", c.getRuntimeType("funcValue"))
+		addParam("signature", types.NewPointer(c.getRuntimeType("typecodeID")))
+		addResult(types.Typ[types.Uintptr])
+	default:
+		panic("unknown runtime call: runtime." + name)
+	}
+	return types.NewSignature(nil, types.NewTuple(params...), types.NewTuple(results...), false)
+}
@@ -150,9 +150,6 @@ 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())
 	}
@@ -15,23 +15,6 @@ 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.
@@ -51,32 +34,56 @@ const (
 	inlineNone
 )

+// functionInfo contains some information about a function or method. In
+// particular, it contains information obtained from pragmas.
+//
+// The linkName value contains a valid link name, even though //go:linkname is
+// not present.
+type functionInfo struct {
+	linkName string     // go:linkname, go:export
+	module   string     // go:wasm-module
+	exported bool       // go:export
+	nobounds bool       // go:nobounds
+	inline   inlineType // go:inline
+}
+
 // getFunction returns the LLVM function for the given *ssa.Function, creating
 // it if needed. It can later be filled with compilerContext.createFunction().
 func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 	info := c.getFunctionInfo(fn)
+	return c.getFunctionRaw(fn.Signature, info)
+}
+
+func (c *compilerContext) getFunctionRaw(sig *types.Signature, info functionInfo) llvm.Value {
 	llvmFn := c.mod.NamedFunction(info.linkName)
 	if !llvmFn.IsNil() {
 		return llvmFn
 	}

 	var retType llvm.Type
-	if fn.Signature.Results() == nil {
+	if sig.Results() == nil {
 		retType = c.ctx.VoidType()
-	} else if fn.Signature.Results().Len() == 1 {
-		retType = c.getLLVMType(fn.Signature.Results().At(0).Type())
+	} else if sig.Results().Len() == 1 {
+		retType = c.getLLVMType(sig.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()))
+		results := make([]llvm.Type, 0, sig.Results().Len())
+		for i := 0; i < sig.Results().Len(); i++ {
+			results = append(results, c.getLLVMType(sig.Results().At(i).Type()))
 		}
 		retType = c.ctx.StructType(results, false)
 	}

 	var paramInfos []paramInfo
-	for _, param := range getParams(fn.Signature) {
+	params := []*types.Var{}
+	if sig.Recv() != nil {
+		params = append(params, sig.Recv())
+	}
+	for i := 0; i < sig.Params().Len(); i++ {
+		params = append(params, sig.Params().At(i))
+	}
+	for _, param := range params {
 		paramType := c.getLLVMType(param.Type())
-		paramFragmentInfos := c.expandFormalParamType(paramType, param.Name(), param.Type())
+		paramFragmentInfos := expandFormalParamType(paramType, param.Name(), param.Type())
 		paramInfos = append(paramInfos, paramFragmentInfos...)
 	}

@@ -84,6 +91,7 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 	// 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
@@ -91,24 +99,8 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 		paramTypes = append(paramTypes, info.llvmType)
 	}

-	fnType := llvm.FunctionType(retType, paramTypes, info.variadic)
+	fnType := llvm.FunctionType(retType, paramTypes, false)
 	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 {
@@ -127,54 +119,13 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 		}
 	}

-	// 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)
@@ -184,22 +135,6 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 			}
 		}
 	}
-
-	// 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
 }

@@ -207,26 +142,29 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 // 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{
+	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.
-		linkName: f.RelString(nil),
+		info.linkName = f.RelString(nil)
+		// Check for //go: pragmas, which may change the link name (among
+		// others).
+		info.parsePragmas(f)
 	}
-	// Check for //go: pragmas, which may change the link name (among others).
-	info.parsePragmas(f)
 	return info
 }

 // parsePragmas is used by getFunctionInfo to parse function pragmas such as
 // //export or //go:noinline.
 func (info *functionInfo) parsePragmas(f *ssa.Function) {
+	// Parse compiler directives in the preceding comments.
 	if f.Syntax() == nil {
 		return
 	}
 	if decl, ok := f.Syntax().(*ast.FuncDecl); ok && decl.Doc != nil {
-
-		// 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 ") {
@@ -243,13 +181,8 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 				if len(parts) != 2 {
 					continue
 				}
-
-				importName = parts[1]
+				info.linkName = 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 {
@@ -271,10 +204,6 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 				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.
@@ -283,93 +212,11 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 				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)
-	}
-	if c.CPU != "" {
-		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("target-cpu", c.CPU))
-	}
-	if c.Features != "" {
-		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("target-features", c.Features))
-	}
-}
-
-// 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).
@@ -377,27 +224,29 @@ 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(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
+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
+								}
 							}
 						}
 					}
@@ -416,25 +265,29 @@ 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
-		alignment := c.targetData.ABITypeAlignment(llvmType)
-		if info.align > alignment {
-			alignment = info.align
-		}
-		if alignment <= 0 || alignment&(alignment-1) != 0 {
+		if info.align < 0 || info.align&(info.align-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(alignment) ^ uint32(alignment-1)
-			llvmGlobal.SetAlignment(alignment)
+			alignInBits = uint32(info.align) ^ uint32(info.align-1)
+			if info.align > c.targetData.ABITypeAlignment(llvmType) {
+				llvmGlobal.SetAlignment(info.align)
+			}
 		}

-		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.program.Fset.Position(g.Pos())
 			diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[pos.Filename], llvm.DIGlobalVariableExpression{
 				Name:        g.RelString(nil),
@@ -454,14 +307,20 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {

 // getGlobalInfo returns some information about a specific global.
 func (c *compilerContext) getGlobalInfo(g *ssa.Global) globalInfo {
-	info := globalInfo{
+	info := globalInfo{}
+	if strings.HasPrefix(g.Name(), "C.") {
+		// Created by CGo: such a name cannot be created by regular C code.
+		info.linkName = g.Name()[2:]
+		info.extern = true
+	} else {
 		// Pick the default linkName.
-		linkName: g.RelString(nil),
-	}
-	// Check for //go: pragmas, which may change the link name (among others).
-	doc := c.astComments[info.linkName]
-	if doc != nil {
-		info.parsePragmas(doc)
+		info.linkName = g.RelString(nil)
+		// Check for //go: pragmas, which may change the link name (among
+		// others).
+		doc := c.astComments[info.linkName]
+		if doc != nil {
+			info.parsePragmas(doc)
+		}
 	}
 	return info
 }
@@ -485,10 +344,6 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 			if err == nil {
 				info.align = align
 			}
-		case "//go:section":
-			if len(parts) == 2 {
-				info.section = parts[1]
-			}
 		}
 	}
 }
@@ -10,14 +10,14 @@ import (
 	"tinygo.org/x/go-llvm"
 )

-// 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) {
+// createSyscall emits an inline system call instruction, depending on the
+// target OS/arch.
+func (b *builder) createSyscall(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.
@@ -56,9 +56,9 @@ func (b *builder) createRawSyscall(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, false)
-		return b.CreateCall(target, args, ""), nil
-	case b.GOARCH == "386" && b.GOOS == "linux":
+		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel)
+		syscallResult = b.CreateCall(target, args, "")
+	case b.GOARCH() == "386" && b.GOOS() == "linux":
 		// Sources:
 		//   syscall(2) man page
 		//   https://stackoverflow.com/a/2538212
@@ -82,9 +82,9 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel, false)
-		return b.CreateCall(target, args, ""), nil
-	case b.GOARCH == "arm" && b.GOOS == "linux":
+		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel)
+		syscallResult = b.CreateCall(target, args, "")
+	case b.GOARCH() == "arm" && b.GOOS() == "linux":
 		// Implement the EABI system call convention for Linux.
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
@@ -114,9 +114,9 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 			constraints += ",~{r" + strconv.Itoa(i) + "}"
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0, false)
-		return b.CreateCall(target, args, ""), nil
-	case b.GOARCH == "arm64" && b.GOOS == "linux":
+		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
+		syscallResult = b.CreateCall(target, args, "")
+	case b.GOARCH() == "arm64" && b.GOOS() == "linux":
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
 		argTypes := []llvm.Type{}
@@ -146,22 +146,13 @@ func (b *builder) createRawSyscall(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, false)
-		return b.CreateCall(target, args, ""), nil
+		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
+		syscallResult = b.CreateCall(target, args, "")
 	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())
 	}
-}
-
-// 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) {
-	switch b.GOOS {
-	case "linux":
-		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:
 		//     var err uintptr
@@ -180,10 +171,6 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		retval = b.CreateInsertValue(retval, errResult, 2, "")
 		return retval, nil
 	case "darwin":
-		syscallResult, err := b.createRawSyscall(call)
-		if err != nil {
-			return syscallResult, err
-		}
 		// Return values: r0, r1 uintptr, err Errno
 		// Pseudocode:
 		//     var err uintptr
@@ -199,71 +186,7 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		retval = b.CreateInsertValue(retval, zero, 1, "")
 		retval = b.CreateInsertValue(retval, errResult, 2, "")
 		return retval, nil
-	case "windows":
-		// On Windows, syscall.Syscall* is basically just a function pointer
-		// call. This is complicated in gc because of stack switching and the
-		// different ABI, but easy in TinyGo: just call the function pointer.
-		// The signature looks like this:
-		//   func Syscall(trap, nargs, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
-
-		// Prepare input values.
-		var paramTypes []llvm.Type
-		var params []llvm.Value
-		for _, val := range call.Args[2:] {
-			param := b.getValue(val)
-			params = append(params, param)
-			paramTypes = append(paramTypes, param.Type())
-		}
-		llvmType := llvm.FunctionType(b.uintptrType, paramTypes, false)
-		fn := b.getValue(call.Args[0])
-		fnPtr := b.CreateIntToPtr(fn, llvm.PointerType(llvmType, 0), "")
-
-		// Prepare some functions that will be called later.
-		setLastError := b.mod.NamedFunction("SetLastError")
-		if setLastError.IsNil() {
-			llvmType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.ctx.Int32Type()}, false)
-			setLastError = llvm.AddFunction(b.mod, "SetLastError", llvmType)
-		}
-		getLastError := b.mod.NamedFunction("GetLastError")
-		if getLastError.IsNil() {
-			llvmType := llvm.FunctionType(b.ctx.Int32Type(), nil, false)
-			getLastError = llvm.AddFunction(b.mod, "GetLastError", llvmType)
-		}
-
-		// Now do the actual call. Pseudocode:
-		//     SetLastError(0)
-		//     r1 = trap(a1, a2, a3, ...)
-		//     err = uintptr(GetLastError())
-		//     return r1, 0, err
-		// Note that SetLastError/GetLastError could be replaced with direct
-		// access to the thread control block, which is probably smaller and
-		// faster. The Go runtime does this in assembly.
-		b.CreateCall(setLastError, []llvm.Value{llvm.ConstNull(b.ctx.Int32Type())}, "")
-		syscallResult := b.CreateCall(fnPtr, params, "")
-		errResult := b.CreateCall(getLastError, nil, "err")
-		if b.uintptrType != b.ctx.Int32Type() {
-			errResult = b.CreateZExt(errResult, b.uintptrType, "err.uintptr")
-		}
-
-		// Return r1, 0, err
-		retval := llvm.ConstNull(b.ctx.StructType([]llvm.Type{b.uintptrType, b.uintptrType, b.uintptrType}, false))
-		retval = b.CreateInsertValue(retval, syscallResult, 0, "")
-		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
-}
@@ -1,88 +1,13 @@
 package main

-// Basic tests that don't need to be split into a separate file.
-
-func addInt(x, y int) int {
+func add(x, y int) int {
 	return x + y
 }

-func equalInt(x, y int) bool {
-	return x == y
+func stringEqual(s string) bool {
+	return s == "s"
 }

-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)
+func closeChan(ch chan int) {
+	close(ch)
 }
@@ -1,204 +1,41 @@
-; ModuleID = 'basic.go'
-source_filename = "basic.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
-target triple = "wasm32-unknown-wasi"
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "armv7m-none-eabi"

-%main.kv = type { float }
-%main.kv.0 = type { 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 opaque
+%runtime.chanSelectState = type { %runtime.channel*, i8* }
+%runtime._string = type { i8*, i32 }

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
+@"main.stringEqual$string" = internal unnamed_addr constant [1 x i8] c"s"

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden i32 @main.addInt(i32 %x, i32 %y, i8* %context) unnamed_addr #0 {
+define internal i32 @main.add(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = add i32 %x, %y
  ret i32 %0
 }

-; Function Attrs: nounwind
-define hidden i1 @main.equalInt(i32 %x, i32 %y, i8* %context) unnamed_addr #0 {
+define internal void @main.closeChan(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = icmp eq i32 %x, %y
-  ret i1 %0
-}
-
-; Function Attrs: nounwind
-define hidden i32 @main.divInt(i32 %x, i32 %y, i8* %context) 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) #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*)
-
-; Function Attrs: nounwind
-define hidden i32 @main.divUint(i32 %x, i32 %y, i8* %context) 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) #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) 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) #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) 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) #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) 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) 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) 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) 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) 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) 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) unnamed_addr #0 {
-entry:
-  ret float %x.r
-}
-
-; Function Attrs: nounwind
-define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context) 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) 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) 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) 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) unnamed_addr #0 {
-entry:
-  call void @"main.foo$1"(%main.kv.0* null, i8* undef)
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @"main.foo$1"(%main.kv.0* dereferenceable_or_null(1) %b, i8* %context) unnamed_addr #0 {
+declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
+
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-attributes #0 = { nounwind }
+define internal i1 @main.stringEqual(i8* %s.data, i32 %s.len, i8* %context, i8* %parentHandle) unnamed_addr {
+entry:
+  %0 = insertvalue %runtime._string zeroinitializer, i8* %s.data, 0
+  %1 = insertvalue %runtime._string %0, i32 %s.len, 1
+  %2 = extractvalue %runtime._string %1, 0
+  %3 = extractvalue %runtime._string %1, 1
+  %4 = call i1 @runtime.stringEqual(i8* %2, i32 %3, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @"main.stringEqual$string", i32 0, i32 0), i32 1, i8* undef, i8* null)
+  ret i1 %4
+}
+
+declare i1 @runtime.stringEqual(i8*, i32, i8*, i32, i8*, i8*)
@@ -1,25 +0,0 @@
-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:
-	}
-}
@@ -1,128 +0,0 @@
-; ModuleID = 'channel.go'
-source_filename = "channel.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
-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.gcData", %"internal/task.state" }
-%"internal/task.gcData" = type { i8* }
-%"internal/task.state" = type { i32, i8*, %"internal/task.stackState", i1 }
-%"internal/task.stackState" = type { i32, i32 }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.chanIntSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context) 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) #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 nofree nosync 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*)
-
-; Function Attrs: argmemonly nofree nosync 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) 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) #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*)
-
-; Function Attrs: nounwind
-define hidden void @main.chanZeroSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context) unnamed_addr #0 {
-entry:
-  %complit = alloca {}, align 8
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %0 = bitcast {}* %complit to i8*
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #0
-  %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) #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) 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) #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) 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) #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*)
-
-attributes #0 = { nounwind }
-attributes #1 = { argmemonly nofree nosync nounwind willreturn }
@@ -1,39 +0,0 @@
-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)
-}
@@ -1,95 +0,0 @@
-; ModuleID = 'float.go'
-source_filename = "float.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
-target triple = "wasm32-unknown-wasi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden i32 @main.f32tou32(float %v, i8* %context) 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) unnamed_addr #0 {
-entry:
-  ret float 0x41F0000000000000
-}
-
-; Function Attrs: nounwind
-define hidden i32 @main.maxu32tof32(i8* %context) unnamed_addr #0 {
-entry:
-  ret i32 -1
-}
-
-; Function Attrs: nounwind
-define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context) 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) 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) 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) 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) 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 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ayke van Laethem	ca7b95039d	interp: do not rely on fixed type names After merging multiple LLVM modules into one, types may have been renamed. Therefore, the interp package should not rely on types to have any particular name.	2020-05-03 15:43:45 +02:00
Ayke van Laethem	7939c060ce	compiler: include type information about the runtime in the compiler These types are often known to the compiler already. Moving them into the compiler is an important step for two related reasons: * It makes the compiler better testable. Together with https://github.com/tinygo-org/tinygo/pull/1008 it will make it possible to test the compiler without having to load the runtime package. * It makes it easier to compile packages independently as the type information of the runtime package doesn't need to be present. I had to use hack to get this to work well: internal/task.Task is now an opaque struct. This is necessary because there is a dependency from runtime.channel -> runtime.channelBlockedList -> *internal/task.Task. I don't want to include the definition of the internal/task.Task struct in the compiler directly as that would make changing the internal/task package a lot harder and the compiler doesn't need to know the layout of that struct anyway.	2020-05-03 15:43:45 +02:00
Ayke van Laethem	dd04f34059	compiler: integrate ir package into compiler package The ir package has long lost its original purpose (which was doing some analysis and optimization on the Go SSA directly). There is very little of it left, which is best integrated directly in the compiler package to avoid unnecessary abstraction.	2020-05-03 15:43:45 +02:00
Ayke van Laethem	f58e75c386	compiler: add tests This commit adds a very small test case. More importantly, it adds a framework for other tests to be added in the future.	2020-05-03 15:43:45 +02:00
Ayke van Laethem	b8db79f6a6	compiler: compile all functions/methods, remove SimpleDCE This is important because once we move to compiling packages independently, SimpleDCE can't work anymore. Instead we'll have to compile all parts of a package and cache that for later reuse.	2020-05-03 15:43:44 +02:00