Adding extra files for testing multiline, globbing, etc.

Started parsing of //go:embed pragmas
2026-07-27 23:28:42 +00:00 · 2021-07-23 17:07:25 -04:00 · 2021-07-19 20:12:44 -04:00
486 changed files with 5195 additions and 17479 deletions
@@ -6,6 +6,52 @@ commands:
      - run:
          name: "Pull submodules"
          command: git submodule update --init
+  apt-dependencies:
+    parameters:
+      llvm:
+        type: string
+    steps:
+      - 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 \
+                llvm-<<parameters.llvm>>-dev \
+                clang-<<parameters.llvm>> \
+                libclang-<<parameters.llvm>>-dev \
+                lld-<<parameters.llvm>> \
+                gcc-arm-linux-gnueabihf \
+                gcc-aarch64-linux-gnu \
+                qemu-system-arm \
+                qemu-user \
+                gcc-avr \
+                avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-8-dev
+  install-node:
+    steps:
+      - run:
+          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
+  install-chrome:
+    steps:
+      - run:
+          name: "Install Chrome"
+          command: |
+            wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
+            sudo apt install ./google-chrome-stable_current_amd64.deb
+  install-wasmtime:
+    steps:
+      - run:
+          name: "Install wasmtime"
+          command: |
+            curl https://wasmtime.dev/install.sh -sSf | bash
+            sudo ln -s ~/.wasmtime/bin/wasmtime /usr/local/bin/wasmtime
  install-xtensa-toolchain:
    parameters:
      variant:
@@ -22,37 +68,29 @@ commands:
    steps:
      - restore_cache:
          keys:
-            - llvm-source-12-v1
+            - llvm-source-11-v2
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-12-v1
+          key: llvm-source-11-v2
          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:
+  build-wasi-libc:
    steps:
      - restore_cache:
          keys:
-            - binaryen-linux-v1
+            - wasi-libc-sysroot-v4
      - 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-v4
          paths:
-            - build/wasm-opt
+            - lib/wasi-libc/sysroot
  test-linux:
    parameters:
      llvm:
@@ -60,23 +98,11 @@ 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
+      - install-chrome
+      - install-wasmtime
      - restore_cache:
          keys:
            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
@@ -91,14 +117,168 @@ commands:
          key: wasi-libc-sysroot-systemclang-v3
          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 tinygo-test
+      - run: make wasmtest
      - save_cache:
          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
          paths:
            - ~/.cache/go-build
            - /go/pkg/mod
      - run: make fmt-check
+  assert-test-linux:
+    steps:
+      - checkout
+      - submodules
+      - run:
+          name: "Install apt dependencies"
+          command: |
+            sudo apt-get update
+            sudo apt-get install \
+                gcc-arm-linux-gnueabihf \
+                libc6-dev-armel-cross \
+                gcc-aarch64-linux-gnu \
+                libc6-dev-arm64-cross \
+                qemu-system-arm \
+                qemu-user \
+                gcc-avr \
+                avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-6-dev
+      - install-node
+      - install-wasmtime
+      - install-xtensa-toolchain:
+          variant: "linux-amd64"
+      - 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-11-linux-v4-assert
+      - run:
+          name: "Build LLVM"
+          command: |
+            if [ ! -f llvm-build/lib/liblldELF.a ]
+            then
+              # fetch LLVM source
+              rm -rf llvm-project
+              make llvm-source
+              # install dependencies
+              sudo apt-get install cmake ninja-build
+              # hack ninja to use less jobs
+              echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
+              chmod +x /go/bin/ninja
+              # build!
+              make ASSERT=1 llvm-build
+              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+            fi
+      - save_cache:
+          key: llvm-build-11-linux-v4-assert
+          paths:
+            llvm-build
+      - run: make ASSERT=1
+      - build-wasi-libc
+      - run:
+          name: "Test TinyGo"
+          command: make ASSERT=1 test
+          environment:
+            # Note: -p=2 limits parallelism to two jobs at a time, which is
+            # necessary to keep memory consumption down and avoid OOM (for a
+            # 2CPU/4GB executor).
+            GOFLAGS: -p=2
+      - save_cache:
+          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - /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 update
+            sudo apt-get install \
+                gcc-arm-linux-gnueabihf \
+                libc6-dev-armel-cross \
+                gcc-aarch64-linux-gnu \
+                libc6-dev-arm64-cross \
+                qemu-system-arm \
+                qemu-user \
+                gcc-avr \
+                avr-libc
+            sudo apt-get install --no-install-recommends libc6-dev-i386 lib32gcc-6-dev
+      - install-node
+      - install-wasmtime
+      - install-xtensa-toolchain:
+          variant: "linux-amd64"
+      - 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-11-linux-v4-noassert
+      - run:
+          name: "Build LLVM"
+          command: |
+            if [ ! -f llvm-build/lib/liblldELF.a ]
+            then
+              # fetch LLVM source
+              rm -rf llvm-project
+              make llvm-source
+              # install dependencies
+              sudo apt-get install cmake ninja-build
+              # hack ninja to use less jobs
+              echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
+              chmod +x /go/bin/ninja
+              # build!
+              make llvm-build
+              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+            fi
+      - save_cache:
+          key: llvm-build-11-linux-v4-noassert
+          paths:
+            llvm-build
+      - build-wasi-libc
+      - run:
+          name: "Test TinyGo"
+          command: make test
+      - run:
+          name: "Install fpm"
+          command: |
+            sudo apt-get install ruby ruby-dev
+            sudo gem install --no-document fpm
+      - run:
+          name: "Build TinyGo release"
+          command: |
+            make release deb -j3
+            cp -p build/release.tar.gz /tmp/tinygo.linux-amd64.tar.gz
+            cp -p build/release.deb    /tmp/tinygo_amd64.deb
+      - store_artifacts:
+          path: /tmp/tinygo.linux-amd64.tar.gz
+      - store_artifacts:
+          path: /tmp/tinygo_amd64.deb
+      - save_cache:
+          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - /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
@@ -106,10 +286,10 @@ commands:
      - run:
          name: "Install dependencies"
          command: |
-            curl https://dl.google.com/go/go1.17.darwin-amd64.tar.gz -o go1.17.darwin-amd64.tar.gz
-            sudo tar -C /usr/local -xzf go1.17.darwin-amd64.tar.gz
+            curl https://dl.google.com/go/go1.16.darwin-amd64.tar.gz -o go1.16.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.16.darwin-amd64.tar.gz
            ln -s /usr/local/go/bin/go /usr/local/bin/go
-            HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake ninja
+            HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu
      - install-xtensa-toolchain:
          variant: "macos"
      - restore_cache:
@@ -118,12 +298,12 @@ commands:
            - go-cache-macos-v3-{{ checksum "go.mod" }}
      - restore_cache:
          keys:
-            - llvm-source-12-macos-v1
+            - llvm-source-11-macos-v3
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-12-macos-v1
+          key: llvm-source-11-macos-v3
          paths:
            - llvm-project/clang/lib/Headers
            - llvm-project/clang/include
@@ -131,37 +311,25 @@ commands:
            - llvm-project/llvm/include
      - restore_cache:
          keys:
-            - llvm-build-12-macos-v1
+            - llvm-build-11-macos-v5
      - run:
          name: "Build LLVM"
          command: |
            if [ ! -f llvm-build/lib/liblldELF.a ]
            then
-              # fetch LLVM source (may only have headers right now)
+              # fetch LLVM source
              rm -rf llvm-project
              make llvm-source
+              # install dependencies
+              HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake ninja
              # build!
              make llvm-build
              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
            fi
      - save_cache:
-          key: llvm-build-12-macos-v1
+          key: llvm-build-11-macos-v5
          paths:
            llvm-build
-      - restore_cache:
-          keys:
-            - binaryen-macos-v1
-      - run:
-          name: "Build Binaryen"
-          command: |
-            if [ ! -f build/wasm-opt ]
-            then
-              make binaryen
-            fi
-      - save_cache:
-          key: binaryen-macos-v1
-          paths:
-            - build/wasm-opt
      - restore_cache:
          keys:
            - wasi-libc-sysroot-macos-v4
@@ -174,8 +342,7 @@ commands:
            - lib/wasi-libc/sysroot
      - run:
          name: "Test TinyGo"
-          command: make test GOTESTFLAGS="-v -short"
-          no_output_timeout: 20m
+          command: make test
      - run:
          name: "Build TinyGo release"
          command: |
@@ -190,7 +357,6 @@ commands:
            tar -C /usr/local/opt -xf /tmp/tinygo.darwin-amd64.tar.gz
            ln -s /usr/local/opt/tinygo/bin/tinygo /usr/local/bin/tinygo
            tinygo version
-      - run: make tinygo-test
      - run: make smoketest AVR=0
      - save_cache:
          key: go-cache-macos-v3-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
@@ -199,18 +365,40 @@ commands:
            - /go/pkg/mod

 jobs:
+  test-llvm10-go113:
+    docker:
+      - image: circleci/golang:1.13-buster
+    steps:
+      - test-linux:
+          llvm: "10"
+  test-llvm10-go114:
+    docker:
+      - image: circleci/golang:1.14-buster
+    steps:
+      - test-linux:
+          llvm: "10"
  test-llvm11-go115:
    docker:
      - image: circleci/golang:1.15-buster
    steps:
      - test-linux:
          llvm: "11"
-  test-llvm12-go116:
+  test-llvm11-go116:
    docker:
      - image: circleci/golang:1.16-buster
    steps:
      - test-linux:
-          llvm: "12"
+          llvm: "11"
+  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: "11.1.0" # macOS 10.14
@@ -222,6 +410,10 @@ jobs:
 workflows:
  test-all:
    jobs:
+      - test-llvm10-go113
+      - test-llvm10-go114
      - test-llvm11-go115
-      - test-llvm12-go116
+      - test-llvm11-go116
+      - build-linux
      - build-macos
+      - assert-test-linux
@@ -1,3 +0,0 @@
-build/
-llvm-*/
-
@@ -1,7 +1,7 @@
 name: CI for tinygo-dev docker container
 on:
  push:
-    branches: [ dev, fix-docker-llvm-build ]
+    branches: [ dev ]

 jobs:
  push_to_registry:
@@ -1,232 +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-12-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-12-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: 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 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: |
-          sudo apt-get install --no-install-recommends \
-              qemu-system-arm \
-              qemu-system-riscv32 \
-              qemu-user \
-              gcc-avr \
-              avr-libc \
-              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-12-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-12-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
-      - 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 gen-device -j4
-      - run: make smoketest
-      - run: make wasmtest
@@ -1,105 +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'
-      - name: Install Ninja
-        shell: bash
-        run: |
-          choco install ninja
-      - 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-12-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-12-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: Cache Binaryen
-        uses: actions/cache@v2
-        id: cache-binaryen
-        with:
-          key: binaryen-windows-v2
-          path: build/wasm-opt.exe
-      - name: Build Binaryen
-        if: steps.cache-binaryen.outputs.cache-hit != 'true'
-        run: make binaryen
-      - 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=build/tinygo AVR=0 XTENSA=0
-      - name: Test stdlib packages
-        run: make tinygo-test
@@ -1,3 +1,4 @@
+build
 docs/_build
 src/device/avr/*.go
 src/device/avr/*.ld
@@ -20,12 +21,8 @@ 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
@@ -23,12 +23,3 @@
 [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
@@ -23,7 +23,7 @@ different guide:
 LLVM, Clang and LLD are quite light on dependencies, requiring only standard
 build tools to be built. Go is of course necessary to build TinyGo itself.

-  * Go (1.15+)
+  * Go (1.13+)
  * Standard build tools (gcc/clang)
  * git
  * CMake
@@ -1,167 +1,3 @@
-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
 ---

@@ -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 `release` 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
+```
@@ -1,8 +1,8 @@
-# TinyGo base stage installs the most recent Go 1.17.x, LLVM 11 and the TinyGo compiler itself.
-FROM golang:1.17 AS tinygo-base
+# TinyGo base stage installs the most recent Go 1.16.x, LLVM 11 and the TinyGo compiler itself.
+FROM golang:1.16 AS tinygo-base

 RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
-    echo "deb http://apt.llvm.org/bullseye/ llvm-toolchain-bullseye-11 main" >> /etc/apt/sources.list && \
+    echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster-11 main" >> /etc/apt/sources.list && \
    apt-get update && \
    apt-get install -y llvm-11-dev libclang-11-dev lld-11 git

@@ -15,7 +15,7 @@ RUN cd /tinygo/ && \
    git submodule sync && \
    git submodule update --init --recursive --force

-COPY ./lib/picolibc-stdio.c /tinygo/lib/picolibc-stdio.c
+COPY ./lib/picolibc-include/* /tinygo/lib/picolibc-include/

 RUN cd /tinygo/ && \
    go install /tinygo/
@@ -29,9 +29,8 @@ COPY --from=tinygo-base /tinygo/targets /tinygo/targets

 RUN cd /tinygo/ && \
    apt-get update && \
-    apt-get install -y make clang-11 libllvm11 lld-11 cmake ninja-build && \
-    mkdir build && \
-    make wasi-libc binaryen
+    apt-get install -y make clang-11 libllvm11 lld-11 && \
+    make wasi-libc

 # tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
 FROM tinygo-base AS tinygo-avr
@@ -10,17 +10,14 @@ LLD_SRC ?= $(LLVM_PROJECTDIR)/lld

 # Try to autodetect LLVM build tools.
 detect = $(shell command -v $(1) 2> /dev/null && echo $(1))
-CLANG ?= $(word 1,$(abspath $(call detect,llvm-build/bin/clang))$(call detect,clang-11)$(call detect,clang))
-LLVM_AR ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-ar))$(call detect,llvm-ar-11)$(call detect,llvm-ar))
-LLVM_NM ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-nm))$(call detect,llvm-nm-11)$(call detect,llvm-nm))
+CLANG ?= $(word 1,$(abspath $(call detect,llvm-build/bin/clang))$(call detect,clang-11)$(call detect,clang-10)$(call detect,clang))
+LLVM_AR ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-ar))$(call detect,llvm-ar-11)$(call detect,llvm-ar-10)$(call detect,llvm-ar))
+LLVM_NM ?= $(word 1,$(abspath $(call detect,llvm-build/bin/llvm-nm))$(call detect,llvm-nm-11)$(call detect,llvm-nm-10)$(call detect,llvm-nm))

 # 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

@@ -41,7 +38,7 @@ 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

-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
@@ -57,15 +54,18 @@ ifeq ($(OS),Windows_NT)
    CGO_LDFLAGS += -static -static-libgcc -static-libstdc++
    CGO_LDFLAGS_EXTRA += -lversion

-    BINARYEN_OPTION += -DCMAKE_EXE_LINKER_FLAGS='-static-libgcc -static-libstdc++'
+    LIBCLANG_NAME = libclang

 else ifeq ($(shell uname -s),Darwin)
    MD5SUM = md5
+    LIBCLANG_NAME = clang
 else ifeq ($(shell uname -s),FreeBSD)
    MD5SUM = md5
+    LIBCLANG_NAME = clang
    START_GROUP = -Wl,--start-group
    END_GROUP = -Wl,--end-group
 else
+    LIBCLANG_NAME = clang
    START_GROUP = -Wl,--start-group
    END_GROUP = -Wl,--end-group
 endif
@@ -81,29 +81,26 @@ LLD_LIBS = $(START_GROUP) $(addprefix -l,$(LLD_LIB_NAMES)) $(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)))
+NINJA_BUILD_TARGETS = clang llvm-config llvm-ar llvm-nm $(addprefix lib/lib,$(addsuffix .a,$(LIBCLANG_NAME) $(CLANG_LIB_NAMES) $(LLD_LIB_NAMES) $(EXTRA_LIB_NAMES)))

 # For static linking.
 ifneq ("$(wildcard $(LLVM_BUILDDIR)/bin/llvm-config*)","")
    CGO_CPPFLAGS+=$(shell $(LLVM_BUILDDIR)/bin/llvm-config --cppflags) -I$(abspath $(LLVM_BUILDDIR))/tools/clang/include -I$(abspath $(CLANG_SRC))/include -I$(abspath $(LLD_SRC))/include
    CGO_CXXFLAGS=-std=c++14
-    CGO_LDFLAGS+=-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+=$(abspath $(LLVM_BUILDDIR))/lib/lib$(LIBCLANG_NAME).a -L$(abspath $(LLVM_BUILDDIR)/lib) $(CLANG_LIBS) $(LLD_LIBS) $(shell $(LLVM_BUILDDIR)/bin/llvm-config --ldflags --libs --system-libs $(LLVM_COMPONENTS)) -lstdc++ $(CGO_LDFLAGS_EXTRA)
 endif


 clean:
 	@rm -rf build

-FMT_PATHS = ./*.go builder cgo compiler interp 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 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:
@@ -127,7 +124,6 @@ build/gen-device-svd: ./tools/gen-device-svd/*.go

 gen-device-esp: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Espressif-Community -interrupts=software lib/cmsis-svd/data/Espressif-Community/ src/device/esp/
-	./build/gen-device-svd -source=https://github.com/posborne/cmsis-svd/tree/master/data/Espressif -interrupts=software lib/cmsis-svd/data/Espressif/ src/device/esp/
 	GO111MODULE=off $(GO) fmt ./src/device/esp

 gen-device-nrf: build/gen-device-svd
@@ -160,32 +156,25 @@ gen-device-rp: build/gen-device-svd

 # Get LLVM sources.
 $(LLVM_PROJECTDIR)/llvm:
-	git clone -b xtensa_release_12.0.1 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
+	git clone -b xtensa_release_11.0.0 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
 llvm-source: $(LLVM_PROJECTDIR)/llvm

 # Configure LLVM.
 TINYGO_SOURCE_DIR=$(shell pwd)
 $(LLVM_BUILDDIR)/build.ninja: llvm-source
-	mkdir -p $(LLVM_BUILDDIR) && cd $(LLVM_BUILDDIR) && cmake -G Ninja $(TINYGO_SOURCE_DIR)/$(LLVM_PROJECTDIR)/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR;Xtensa" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_LIBEDIT=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DLLVM_ENABLE_OCAMLDOC=OFF -DLLVM_ENABLE_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;Xtensa" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_LIBEDIT=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DLLVM_ENABLE_OCAMLDOC=OFF -DLLVM_ENABLE_LIBXML2=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF -DCLANG_ENABLE_STATIC_ANALYZER=OFF -DCLANG_ENABLE_ARCMT=OFF $(LLVM_OPTION)

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

-# 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)

 # 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.
@@ -194,51 +183,23 @@ tinygo:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -buildmode exe -o build/tinygo$(EXE) -tags byollvm -ldflags="-X main.gitSha1=`git rev-parse --short HEAD`" .

 test: wasi-libc
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(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 -buildmode exe -tags byollvm ./builder ./cgo ./compileopts ./compiler ./interp ./transform .

 TEST_PACKAGES = \
-	compress/bzip2 \
-	compress/flate \
-	compress/zlib \
 	container/heap \
 	container/list \
 	container/ring \
 	crypto/des \
-	crypto/dsa \
-	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 \
-	index/suffixarray \
-	internal/itoa \
-	internal/profile \
+	hash/crc64 \
 	math \
 	math/cmplx \
-	net/http/internal/ascii \
-	net/mail \
-	os \
-	path \
-	reflect \
-	testing \
-	testing/iotest \
 	text/scanner \
-	unicode \
-	unicode/utf16 \
 	unicode/utf8 \

 # Test known-working standard library packages.
@@ -247,11 +208,8 @@ TEST_PACKAGES = \
 tinygo-test:
 	$(TINYGO) test $(TEST_PACKAGES)

-.PHONY: smoketest smoketest-commands
+.PHONY: smoketest
 smoketest:
-	@go run ./src/cmd/run-smoketest make smoketest-commands
-
-smoketest-commands:
 	$(TINYGO) version
 	# test all examples (except pwm)
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/blinky1
@@ -285,20 +243,18 @@ smoketest-commands:
 	$(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=hifive1b             examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=reelboard            examples/blinky1
+	$(TINYGO) build             -o test.wasm -tags=reelboard            examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=pca10040             examples/blinky2
+	$(TINYGO) build             -o test.wasm -tags=pca10040             examples/blinky2
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=pca10056             examples/blinky2
+	$(TINYGO) build             -o test.wasm -tags=pca10056             examples/blinky2
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=circuitplay_express  examples/blinky1
+	$(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
@@ -402,8 +358,6 @@ endif
 	@$(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
@@ -436,8 +390,6 @@ ifneq ($(STM32), 0)
 	@$(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
@@ -446,8 +398,6 @@ ifneq ($(STM32), 0)
 	@$(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=lorae5              examples/blinky1
-	@$(MD5SUM) test.hex
 endif
 ifneq ($(AVR), 0)
 	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
@@ -474,23 +424,15 @@ ifneq ($(XTENSA), 0)
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target=nodemcu             examples/blinky1
 	@$(MD5SUM) test.bin
-	$(TINYGO) build -size short -o test.bin -target m5stack-core2       examples/serial
-	@$(MD5SUM) test.bin
-	$(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.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
+	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/export
+	$(TINYGO) build             -o wasm.wasm -target=wasm               examples/wasm/main
 	# test various compiler flags
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -gc=none -scheduler=none examples/blinky1
 	@$(MD5SUM) test.hex
@@ -502,87 +444,46 @@ endif
 	@$(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


 wasmtest:
 	$(GO) test ./tests/wasm

-build/release: tinygo gen-device wasi-libc binaryen
+build/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/armv6m-unknown-unknown-eabi
-	@mkdir -p build/release/tinygo/pkg/armv7m-unknown-unknown-eabi
-	@mkdir -p build/release/tinygo/pkg/armv7em-unknown-unknown-eabi
+	@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
-	@cp -p  build/wasm-opt$(EXE)         build/release/tinygo/bin
 	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
 	@cp -rp lib/CMSIS/CMSIS/Include      build/release/tinygo/lib/CMSIS/CMSIS
 	@cp -rp lib/CMSIS/README.md          build/release/tinygo/lib/CMSIS
 	@cp -rp lib/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt/lib
 	@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=armv6m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv6m-unknown-unknown-eabi/compiler-rt compiler-rt
-	./build/tinygo build-library -target=armv7m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv7m-unknown-unknown-eabi/compiler-rt compiler-rt
-	./build/tinygo build-library -target=armv7em-unknown-unknown-eabi -o build/release/tinygo/pkg/armv7em-unknown-unknown-eabi/compiler-rt compiler-rt
-	./build/tinygo build-library -target=armv6m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv6m-unknown-unknown-eabi/picolibc picolibc
-	./build/tinygo build-library -target=armv7m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv7m-unknown-unknown-eabi/picolibc picolibc
-	./build/tinygo build-library -target=armv7em-unknown-unknown-eabi -o build/release/tinygo/pkg/armv7em-unknown-unknown-eabi/picolibc picolibc
+	./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

 release: build/release
 	tar -czf build/release.tar.gz -C build/release tinygo
@@ -1,6 +1,6 @@
 # TinyGo - Go compiler for small places

-[![CircleCI](https://circleci.com/gh/tinygo-org/tinygo/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/tinygo/tree/dev) [![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)
+[![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,7 +43,7 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for

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

-The following 74 microcontroller boards are currently supported:
+The following 68 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)
@@ -69,7 +69,6 @@ The following 74 microcontroller boards are currently supported:
 * [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)
@@ -84,8 +83,6 @@ The following 74 microcontroller boards are currently supported:
 * [ESP32](https://www.espressif.com/en/products/socs/esp32)
 * [ESP8266](https://www.espressif.com/en/products/socs/esp8266)
 * [Game Boy Advance](https://en.wikipedia.org/wiki/Game_Boy_Advance)
-* [M5Stack](https://docs.m5stack.com/en/core/basic)
-* [M5Stack Core2](https://shop.m5stack.com/products/m5stack-core2-esp32-iot-development-kit)
 * [Makerdiary nRF52840-MDK](https://wiki.makerdiary.com/nrf52840-mdk/)
 * [Makerdiary nRF52840-MDK USB Dongle](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/)
 * [Microchip SAM E54 Xplained Pro](https://www.microchip.com/developmenttools/productdetails/atsame54-xpro)
@@ -104,10 +101,8 @@ The following 74 microcontroller boards are currently supported:
 * [PJRC Teensy 4.0](https://www.pjrc.com/store/teensy40.html)
 * [ProductivityOpen P1AM-100](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html)
 * [Raspberry Pi Pico](https://www.raspberrypi.org/products/raspberry-pi-pico/)
-* [Raytac MDBT50Q-RX Dongle (with TinyUF2 bootloader)](https://www.adafruit.com/product/5199)
 * [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html)
 * [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
-* [Seeed 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)
 * [SiFIve HiFive1](https://www.sifive.com/boards/hifive1)
 * [ST Micro "Nucleo" F103RB](https://www.st.com/en/evaluation-tools/nucleo-f103rb.html)
@@ -115,7 +110,6 @@ The following 74 microcontroller boards are currently supported:
 * [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)
 * [ST Micro STM32F407 "Discovery"](https://www.st.com/en/evaluation-tools/stm32f4discovery.html)
 * [X9 Pro smartwatch](https://github.com/curtpw/nRF5x-device-reverse-engineering/tree/master/X9-nrf52832-activity-tracker/)
@@ -145,7 +139,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

@@ -0,0 +1,88 @@
+# Avoid lengthy LLVM rebuilds on each newly pushed branch. Pull requests will
+# be built anyway.
+trigger:
+- release
+- dev
+
+jobs:
+- job: Build
+  timeoutInMinutes: 240 # 4h
+  pool:
+    vmImage: 'VS2017-Win2016'
+  steps:
+    - task: GoTool@0
+      inputs:
+        version: '1.16'
+    - checkout: self
+      fetchDepth: 1
+    - task: Cache@2
+      displayName: Cache LLVM source
+      inputs:
+        key: llvm-source-11-windows-v1
+        path: llvm-project
+    - task: Bash@3
+      displayName: Download LLVM source
+      inputs:
+        targetType: inline
+        script: make llvm-source
+    - task: CacheBeta@0
+      displayName: Cache LLVM build
+      inputs:
+        key: llvm-build-11-windows-v5
+        path: llvm-build
+    - task: Bash@3
+      displayName: Build LLVM
+      inputs:
+        targetType: inline
+        script: |
+          if [ ! -f llvm-build/lib/liblldELF.a ]
+          then
+            # install dependencies
+            choco install ninja
+            # hack ninja to use fewer jobs
+            echo -e 'C:\\ProgramData\\Chocolatey\\bin\\ninja -j4 %*' > /usr/bin/ninja.bat
+            # build!
+            make llvm-build
+          fi
+    - task: Bash@3
+      displayName: Install QEMU
+      inputs:
+        targetType: inline
+        script: choco install qemu --version=2020.06.12
+    - task: CacheBeta@0
+      displayName: Cache wasi-libc sysroot
+      inputs:
+        key: wasi-libc-sysroot-v4
+        path: lib/wasi-libc/sysroot
+    - task: Bash@3
+      displayName: Build wasi-libc
+      inputs:
+        targetType: inline
+        script: PATH=/usr/bin:$PATH make wasi-libc
+    - task: Bash@3
+      displayName: Test TinyGo
+      inputs:
+        targetType: inline
+        script: |
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          unset GOROOT
+          make test
+    - task: Bash@3
+      displayName: Build TinyGo release tarball
+      inputs:
+        targetType: inline
+        script: |
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          unset GOROOT
+          make build/release -j4
+    - publish: $(System.DefaultWorkingDirectory)/build/release/tinygo
+      displayName: Publish zip as artifact
+      artifact: tinygo
+    - task: Bash@3
+      displayName: Smoke tests
+      inputs:
+        targetType: inline
+        script: |
+          export PATH="$PATH:./llvm-build/bin:/c/Program Files/qemu"
+          unset GOROOT
+          make smoketest TINYGO=build/tinygo AVR=0 XTENSA=0
@@ -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
 		}
@@ -16,14 +16,11 @@ import (
 	"io/ioutil"
 	"math/bits"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"runtime"
 	"sort"
-	"strconv"
 	"strings"

-	"github.com/tinygo-org/tinygo/cgo"
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/compiler"
 	"github.com/tinygo-org/tinygo/goenv"
@@ -63,7 +60,6 @@ type BuildResult struct {
 // implementation of an imported package changes.
 type packageAction struct {
 	ImportPath       string
-	CGoVersion       int // cgo.Version
 	CompilerVersion  int // compiler.Version
 	InterpVersion    int // interp.Version
 	LLVMVersion      string
@@ -90,44 +86,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	}
 	defer os.RemoveAll(dir)

-	// Check for a libc dependency.
-	// As a side effect, this also creates the headers for the given libc, if
-	// the libc needs them.
-	root := goenv.Get("TINYGOROOT")
-	var libcDependencies []*compileJob
-	switch config.Target.Libc {
-	case "musl":
-		job, err := Musl.load(config, dir)
-		if err != nil {
-			return err
-		}
-		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(job.result), "crt1.o")))
-		libcDependencies = append(libcDependencies, job)
-	case "picolibc":
-		libcJob, err := Picolibc.load(config, dir)
-		if err != nil {
-			return err
-		}
-		libcDependencies = append(libcDependencies, libcJob)
-	case "wasi-libc":
-		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
-		if _, err := os.Stat(path); os.IsNotExist(err) {
-			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
-		}
-		libcDependencies = append(libcDependencies, dummyCompileJob(path))
-	case "mingw-w64":
-		_, err := MinGW.load(config, dir)
-		if err != nil {
-			return err
-		}
-		libcDependencies = append(libcDependencies, makeMinGWExtraLibs(dir)...)
-	case "":
-		// no library specified, so nothing to do
-	default:
-		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
-	}
-
-	optLevel, sizeLevel, _ := config.OptLevels()
 	compilerConfig := &compiler.Config{
 		Triple:          config.Triple(),
 		CPU:             config.CPU(),
@@ -136,14 +94,14 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		GOARCH:          config.GOARCH(),
 		CodeModel:       config.CodeModel(),
 		RelocationModel: config.RelocationModel(),
-		SizeLevel:       sizeLevel,

 		Scheduler:          config.Scheduler(),
 		FuncImplementation: config.FuncImplementation(),
 		AutomaticStackSize: config.AutomaticStackSize(),
 		DefaultStackSize:   config.Target.DefaultStackSize,
 		NeedsStackObjects:  config.NeedsStackObjects(),
-		Debug:              true,
+		Debug:              config.Debug(),
+		LLVMFeatures:       config.LLVMFeatures(),
 	}

 	// Load the target machine, which is the LLVM object that contains all
@@ -166,6 +124,11 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		return err
 	}

+	// The slice of jobs that orchestrates most of the build.
+	// This is somewhat like an in-memory Makefile with each job being a
+	// Makefile target.
+	var jobs []*compileJob
+
 	// Create the *ssa.Program. This does not yet build the entire SSA of the
 	// program so it's pretty fast and doesn't need to be parallelized.
 	program := lprogram.LoadSSA()
@@ -175,6 +138,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	var packageJobs []*compileJob
 	packageBitcodePaths := make(map[string]string)
 	packageActionIDs := make(map[string]string)
+	optLevel, sizeLevel, _ := config.OptLevels()
 	for _, pkg := range lprogram.Sorted() {
 		pkg := pkg // necessary to avoid a race condition

@@ -188,7 +152,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		// the parameters for the build.
 		actionID := packageAction{
 			ImportPath:       pkg.ImportPath,
-			CGoVersion:       cgo.Version,
 			CompilerVersion:  compiler.Version,
 			InterpVersion:    interp.Version,
 			LLVMVersion:      llvm.Version,
@@ -249,50 +212,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return errors.New("verification error after compiling package " + pkg.ImportPath)
 				}

-				// Load bitcode of CGo headers and join the modules together.
-				// This may seem vulnerable to cache problems, but this is not
-				// the case: the Go code that was just compiled already tracks
-				// all C files that are read and hashes them.
-				// These headers could be compiled in parallel but the benefit
-				// is so small that it's probably not worth parallelizing.
-				// Packages are compiled independently anyway.
-				for _, cgoHeader := range pkg.CGoHeaders {
-					// Store the header text in a temporary file.
-					f, err := ioutil.TempFile(dir, "cgosnippet-*.c")
-					if err != nil {
-						return err
-					}
-					_, err = f.Write([]byte(cgoHeader))
-					if err != nil {
-						return err
-					}
-					f.Close()
-
-					// Compile the code (if there is any) to bitcode.
-					flags := append([]string{"-c", "-emit-llvm", "-o", f.Name() + ".bc", f.Name()}, pkg.CFlags...)
-					if config.Options.PrintCommands != nil {
-						config.Options.PrintCommands("clang", flags...)
-					}
-					err = runCCompiler(flags...)
-					if err != nil {
-						return &commandError{"failed to build CGo header", "", err}
-					}
-
-					// Load and link the bitcode.
-					// This makes it possible to optimize the functions defined
-					// in the header together with the Go code. In particular,
-					// this allows inlining. It also ensures there is only one
-					// file per package to cache.
-					headerMod, err := mod.Context().ParseBitcodeFile(f.Name() + ".bc")
-					if err != nil {
-						return fmt.Errorf("failed to load bitcode file: %w", err)
-					}
-					err = llvm.LinkModules(mod, headerMod)
-					if err != nil {
-						return fmt.Errorf("failed to link module: %w", err)
-					}
-				}
-
 				// Erase all globals that are part of the undefinedGlobals list.
 				// This list comes from the -ldflags="-X pkg.foo=val" option.
 				// Instead of setting the value directly in the AST (which would
@@ -327,6 +246,16 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return errors.New("verification error after interpreting " + pkgInit.Name())
 				}

+				if sizeLevel >= 2 {
+					// Set the "optsize" attribute to make slightly smaller
+					// binaries at the cost of some performance.
+					kind := llvm.AttributeKindID("optsize")
+					attr := mod.Context().CreateEnumAttribute(kind, 0)
+					for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+						fn.AddFunctionAttr(attr)
+					}
+				}
+
 				// Run function passes for each function in the module.
 				// These passes are intended to be run on each function right
 				// after they're created to reduce IR size (and maybe also for
@@ -382,6 +311,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				return os.Rename(f.Name(), bitcodePath)
 			},
 		}
+		jobs = append(jobs, job)
 		packageJobs = append(packageJobs, job)
 	}

@@ -412,7 +342,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			llvmInitFn := mod.NamedFunction("runtime.initAll")
 			llvmInitFn.SetLinkage(llvm.InternalLinkage)
 			llvmInitFn.SetUnnamedAddr(true)
-			transform.AddStandardAttributes(llvmInitFn, config)
 			llvmInitFn.Param(0).SetName("context")
 			llvmInitFn.Param(1).SetName("parentHandle")
 			block := mod.Context().AddBasicBlock(llvmInitFn, "entry")
@@ -473,13 +402,14 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			return nil
 		},
 	}
+	jobs = append(jobs, programJob)

 	// Check whether we only need to create an object file.
 	// If so, we don't need to link anything and will be finished quickly.
 	outext := filepath.Ext(outpath)
 	if outext == ".o" || outext == ".bc" || outext == ".ll" {
 		// Run jobs to produce the LLVM module.
-		err := runJobs(programJob, config.Options.Parallelism)
+		err := runJobs(jobs)
 		if err != nil {
 			return err
 		}
@@ -520,29 +450,30 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			return ioutil.WriteFile(objfile, llvmBuf.Bytes(), 0666)
 		},
 	}
+	jobs = append(jobs, outputObjectFileJob)

 	// Prepare link command.
 	linkerDependencies := []*compileJob{outputObjectFileJob}
 	executable := filepath.Join(dir, "main")
-	if config.GOOS() == "windows" {
-		executable += ".exe"
-	}
 	tmppath := executable // final file
 	ldflags := append(config.LDFlags(), "-o", executable)

 	// Add compiler-rt dependency if needed. Usually this is a simple load from
 	// a cache.
 	if config.Target.RTLib == "compiler-rt" {
-		job, err := CompilerRT.load(config, dir)
+		job, err := CompilerRT.load(config.Triple(), config.CPU(), dir)
 		if err != nil {
 			return err
 		}
+		jobs = append(jobs, job.dependencies...)
+		jobs = append(jobs, job)
 		linkerDependencies = append(linkerDependencies, job)
 	}

 	// Add jobs to compile extra files. These files are in C or assembly and
 	// contain things like the interrupt vector table and low level operations
 	// such as stack switching.
+	root := goenv.Get("TINYGOROOT")
 	for _, path := range config.ExtraFiles() {
 		abspath := filepath.Join(root, path)
 		job := &compileJob{
@@ -553,6 +484,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				return err
 			},
 		}
+		jobs = append(jobs, job)
 		linkerDependencies = append(linkerDependencies, job)
 	}

@@ -571,6 +503,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return err
 				},
 			}
+			jobs = append(jobs, job)
 			linkerDependencies = append(linkerDependencies, job)
 		}
 	}
@@ -581,48 +514,34 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		ldflags = append(ldflags, lprogram.LDFlags...)
 	}

-	// Add libc dependencies, if they exist.
-	linkerDependencies = append(linkerDependencies, libcDependencies...)
-
-	// Strip debug information with -no-debug.
-	if !config.Debug() {
-		for _, tag := range config.BuildTags() {
-			if tag == "baremetal" {
-				// Don't use -no-debug on baremetal targets. It makes no sense:
-				// the debug information isn't flashed to the device anyway.
-				return fmt.Errorf("stripping debug information is unnecessary for baremetal targets")
-			}
+	// Add libc dependency if needed.
+	switch config.Target.Libc {
+	case "picolibc":
+		job, err := Picolibc.load(config.Triple(), config.CPU(), dir)
+		if err != nil {
+			return err
 		}
-		if config.Target.Linker == "wasm-ld" {
-			// Don't just strip debug information, also compress relocations
-			// while we're at it. Relocations can only be compressed when debug
-			// information is stripped.
-			ldflags = append(ldflags, "--strip-debug", "--compress-relocations")
-		} else if config.Target.Linker == "ld.lld" {
-			// ld.lld is also used on Linux.
-			ldflags = append(ldflags, "--strip-debug")
-		} else {
-			switch config.GOOS() {
-			case "linux":
-				// Either real linux or an embedded system (like AVR) that
-				// pretends to be Linux. It's a ELF linker wrapped by GCC in any
-				// case (not ld.lld - that case is handled above).
-				ldflags = append(ldflags, "-Wl,--strip-debug")
-			case "darwin":
-				// MacOS (darwin) doesn't have a linker flag to strip debug
-				// information. Apple expects you to use the strip command
-				// instead.
-				return errors.New("cannot remove debug information: MacOS doesn't suppor this linker flag")
-			default:
-				// Other OSes may have different flags.
-				return errors.New("cannot remove debug information: unknown OS: " + config.GOOS())
-			}
+		// The library needs to be compiled (cache miss).
+		jobs = append(jobs, job.dependencies...)
+		jobs = append(jobs, job)
+		linkerDependencies = append(linkerDependencies, job)
+	case "wasi-libc":
+		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
+		if _, err := os.Stat(path); os.IsNotExist(err) {
+			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
 		}
+		job := dummyCompileJob(path)
+		jobs = append(jobs, job)
+		linkerDependencies = append(linkerDependencies, job)
+	case "":
+		// no library specified, so nothing to do
+	default:
+		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
 	}

 	// Create a linker job, which links all object files together and does some
 	// extra stuff that can only be done after linking.
-	linkJob := &compileJob{
+	jobs = append(jobs, &compileJob{
 		description:  "link",
 		dependencies: linkerDependencies,
 		run: func(job *compileJob) error {
@@ -669,62 +588,22 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				}
 			}

-			// Run wasm-opt if necessary.
-			if config.Scheduler() == "asyncify" {
-				var optLevel, shrinkLevel int
-				switch config.Options.Opt {
-				case "none", "0":
-				case "1":
-					optLevel = 1
-				case "2":
-					optLevel = 2
-				case "s":
-					optLevel = 2
-					shrinkLevel = 1
-				case "z":
-					optLevel = 2
-					shrinkLevel = 2
-				default:
-					return fmt.Errorf("unknown opt level: %q", config.Options.Opt)
-				}
-				cmd := exec.Command(goenv.Get("WASMOPT"), "--asyncify", "-g",
-					"--optimize-level", strconv.Itoa(optLevel),
-					"--shrink-level", strconv.Itoa(shrinkLevel),
-					executable, "--output", executable)
-				cmd.Stdout = os.Stdout
-				cmd.Stderr = os.Stderr
-
-				err := cmd.Run()
-				if err != nil {
-					return fmt.Errorf("wasm-opt failed: %w", err)
-				}
-			}
-
-			// Print code size if requested.
 			if config.Options.PrintSizes == "short" || config.Options.PrintSizes == "full" {
-				packagePathMap := make(map[string]string, len(lprogram.Packages))
-				for _, pkg := range lprogram.Sorted() {
-					packagePathMap[pkg.OriginalDir()] = pkg.Pkg.Path()
-				}
-				sizes, err := loadProgramSize(executable, packagePathMap)
+				sizes, err := loadProgramSize(executable)
 				if err != nil {
 					return err
 				}
 				if config.Options.PrintSizes == "short" {
 					fmt.Printf("   code    data     bss |   flash     ram\n")
-					fmt.Printf("%7d %7d %7d | %7d %7d\n", sizes.Code+sizes.ROData, sizes.Data, sizes.BSS, sizes.Flash(), sizes.RAM())
+					fmt.Printf("%7d %7d %7d | %7d %7d\n", sizes.Code, sizes.Data, sizes.BSS, sizes.Code+sizes.Data, sizes.Data+sizes.BSS)
 				} else {
-					if !config.Debug() {
-						fmt.Println("warning: data incomplete, remove the -no-debug flag for more detail")
-					}
 					fmt.Printf("   code  rodata    data     bss |   flash     ram | package\n")
-					fmt.Printf("------------------------------- | --------------- | -------\n")
 					for _, name := range sizes.sortedPackageNames() {
 						pkgSize := sizes.Packages[name]
 						fmt.Printf("%7d %7d %7d %7d | %7d %7d | %s\n", pkgSize.Code, pkgSize.ROData, pkgSize.Data, pkgSize.BSS, pkgSize.Flash(), pkgSize.RAM(), name)
 					}
-					fmt.Printf("------------------------------- | --------------- | -------\n")
-					fmt.Printf("%7d %7d %7d %7d | %7d %7d | total\n", sizes.Code, sizes.ROData, sizes.Data, sizes.BSS, sizes.Code+sizes.ROData+sizes.Data, sizes.Data+sizes.BSS)
+					fmt.Printf("%7d %7d %7d %7d | %7d %7d | (sum)\n", sizes.Sum.Code, sizes.Sum.ROData, sizes.Sum.Data, sizes.Sum.BSS, sizes.Sum.Flash(), sizes.Sum.RAM())
+					fmt.Printf("%7d       - %7d %7d | %7d %7d | (all)\n", sizes.Code, sizes.Data, sizes.BSS, sizes.Code+sizes.Data, sizes.Data+sizes.BSS)
 				}
 			}

@@ -735,12 +614,12 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil

 			return nil
 		},
-	}
+	})

 	// Run all jobs to compile and link the program.
 	// Do this now (instead of after elf-to-hex and similar conversions) as it
 	// is simpler and cannot be parallelized.
-	err = runJobs(linkJob, config.Options.Parallelism)
+	err = runJobs(jobs)
 	if err != nil {
 		return err
 	}
@@ -765,7 +644,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		if err != nil {
 			return err
 		}
-	case "esp32", "esp32c3", "esp8266":
+	case "esp32", "esp8266":
 		// Special format for the ESP family of chips (parsed by the ROM
 		// bootloader).
 		tmppath = filepath.Join(dir, "main"+outext)
@@ -832,7 +711,7 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 	// stack-allocated values.
 	// Use -wasm-abi=generic to disable this behaviour.
 	if config.WasmAbi() == "js" {
-		err := transform.ExternalInt64AsPtr(mod, config)
+		err := transform.ExternalInt64AsPtr(mod)
 		if err != nil {
 			return err
 		}
@@ -0,0 +1,105 @@
+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.
+func cacheLoad(name 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.
+func cacheStore(tmppath, name 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 = copyFile(tmppath, cachepath)
+	if err != nil {
+		return "", err
+	}
+	return cachepath, nil
+}
+
+// copyFile copies the given file from src to dst. It can copy over
+// a possibly already existing file at the destination.
+func copyFile(src, dst string) error {
+	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())
-}
@@ -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...)
@@ -155,10 +155,6 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands

 	// 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
@@ -21,7 +21,6 @@ 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" {
@@ -29,7 +28,6 @@ func init() {
 		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
 		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
 		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")
-		commands["lldb"] = append(commands["lldb"], prefix+"lldb")
 	}
 	// Add the path for when LLVM was installed with the installer from
 	// llvm.org, which by default doesn't add LLVM to the $PATH environment
@@ -38,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" {
@@ -46,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,7 +13,7 @@ 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
 	}
@@ -33,8 +33,8 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	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 < 13 || minor > 16 {
+		return nil, fmt.Errorf("requires go version 1.13 through 1.16, got go%d.%d", major, minor)
 	}

 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
@@ -78,21 +78,11 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	// An added benefit is that we don't need to check for errors all the time.
 	outf := &bytes.Buffer{}

-	// Chip IDs. Source:
-	// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L22
-	chip_id := map[string]uint16{
-		"esp32":   0x0000,
-		"esp32c3": 0x0005,
-	}[format]
-
 	// Image header.
 	switch format {
-	case "esp32", "esp32c3":
+	case "esp32":
 		// 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.
+		// https://github.com/espressif/esp-idf/blob/8fbb63c2/components/bootloader_support/include/esp_image_format.h#L58
 		binary.Write(outf, binary.LittleEndian, struct {
 			magic          uint8
 			segment_count  uint8
@@ -101,18 +91,15 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 			entry_addr     uint32
 			wp_pin         uint8
 			spi_pin_drv    [3]uint8
-			chip_id        uint16
-			min_chip_rev   uint8
-			reserved       [8]uint8
+			reserved       [11]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
+			spi_mode:       0, // irrelevant, replaced by esptool when flashing
+			spi_speed_size: 0, // spi_speed, spi_size: replaced by esptool when flashing
 			entry_addr:     uint32(inf.Entry),
 			wp_pin:         0xEE, // disable WP pin
-			chip_id:        chip_id,
 			hash_appended:  true, // add a SHA256 hash
 		})
 	case "esp8266":
@@ -155,7 +142,7 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	outf.Write(make([]byte, 15-outf.Len()%16))
 	outf.WriteByte(checksum)

-	if format != "esp8266" {
+	if format == "esp32" {
 		// SHA256 hash (to protect against image corruption, not for security).
 		hash := sha256.Sum256(outf.Bytes())
 		outf.Write(hash[:])
@@ -65,45 +65,19 @@ func (job *compileJob) readyToRun() bool {
 	return true
 }

-// runJobs runs the indicated job and all its dependencies. For every job, all
-// the dependencies are run first. It returns the error of the first job that
-// fails.
-// It runs all jobs in the order of the dependencies slice, depth-first.
-// Therefore, if some jobs are preferred to run before others, they should be
-// ordered as such in the job dependencies.
-func runJobs(job *compileJob, parallelism int) error {
-	if parallelism == 0 {
-		// Have a default, if the parallelism isn't set. This is useful for
-		// tests.
-		parallelism = runtime.NumCPU()
-	}
-	if parallelism < 1 {
-		return fmt.Errorf("-p flag must be at least 1, provided -p=%d", parallelism)
-	}
-
-	// Create a slice of jobs to run, where all dependencies are run in order.
-	jobs := []*compileJob{}
-	addedJobs := map[*compileJob]struct{}{}
-	var addJobs func(*compileJob)
-	addJobs = func(job *compileJob) {
-		if _, ok := addedJobs[job]; ok {
-			return
-		}
-		for _, dep := range job.dependencies {
-			addJobs(dep)
-		}
-		jobs = append(jobs, job)
-		addedJobs[job] = struct{}{}
-	}
-	addJobs(job)
-
+// runJobs runs all the jobs indicated in the jobs slice and returns the error
+// of the first job that fails to run.
+// It runs all jobs in the order of the slice, as long as all dependencies have
+// already run. Therefore, if some jobs are preferred to run before others, they
+// should be ordered as such in this slice.
+func runJobs(jobs []*compileJob) error {
 	// Create channels to communicate with the workers.
 	doneChan := make(chan *compileJob)
 	workerChan := make(chan *compileJob)
 	defer close(workerChan)

 	// Start a number of workers.
-	for i := 0; i < parallelism; i++ {
+	for i := 0; i < runtime.NumCPU(); i++ {
 		if jobRunnerDebug {
 			fmt.Println("## starting worker", i)
 		}
@@ -118,7 +92,7 @@ func runJobs(job *compileJob, parallelism int) error {
 	for {
 		// If there are free workers, try starting a new job (if one is
 		// available). If it succeeds, try again to fill the entire worker pool.
-		if numRunningJobs < parallelism {
+		if numRunningJobs < runtime.NumCPU() {
 			jobToRun := nextJob(jobs)
 			if jobToRun != nil {
 				// Start job.
@@ -1,12 +1,10 @@
 package builder

 import (
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"

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

@@ -16,87 +14,72 @@ 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, err := l.load(config, tmpdir)
+// The resulting file is stored in the provided tmpdir, which is expected to be
+// removed after the Load call.
+func (l *Library) Load(target, tmpdir string) (path string, err error) {
+	job, err := l.load(target, "", tmpdir)
 	if err != nil {
 		return "", err
 	}
-	err = runJobs(job, config.Options.Parallelism)
-	return filepath.Dir(job.result), err
+	jobs := append([]*compileJob{job}, job.dependencies...)
+	err = runJobs(jobs)
+	return 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.
+// cached. The path is stored as job.result but is only valid if the job and
+// job.dependencies have been run.
 // The provided tmpdir will be used to store intermediary files and possibly the
 // output archive file, it is expected to be removed after use.
-// As a side effect, this call creates the library header files if they didn't
-// exist yet.
-func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJob, err error) {
-	outdir, precompiled := config.LibcPath(l.name)
-	archiveFilePath := filepath.Join(outdir, "lib.a")
-	if precompiled {
+func (l *Library) load(target, cpu, tmpdir string) (job *compileJob, 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), nil
+		return dummyCompileJob(precompiledPath), nil
+	}
+
+	var outfile string
+	if cpu != "" {
+		outfile = l.name + "-" + target + "-" + cpu + ".a"
+	} else {
+		outfile = l.name + "-" + target + ".a"
 	}

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

-	// Create the destination directory where the components of this library
-	// (lib.a file, include directory) are placed.
-	outname := filepath.Base(outdir)
-	err = os.MkdirAll(filepath.Join(goenv.Get("GOCACHE"), outname), 0o777)
-	if err != nil {
-		// Could not create directory (and not because it already exists).
-		return nil, err
-	}
-
-	// Make headers if needed.
-	headerPath := filepath.Join(outdir, "include")
-	target := config.Triple()
-	if l.makeHeaders != nil {
-		if _, err = os.Stat(headerPath); err != nil {
-			temporaryHeaderPath, err := ioutil.TempDir(outdir, "include.tmp*")
-			if err != nil {
-				return nil, err
-			}
-			defer os.RemoveAll(temporaryHeaderPath)
-			err = l.makeHeaders(target, temporaryHeaderPath)
-			if err != nil {
-				return nil, err
-			}
-			err = os.Rename(temporaryHeaderPath, headerPath)
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-
 	remapDir := filepath.Join(os.TempDir(), "tinygo-"+l.name)
 	dir := filepath.Join(tmpdir, "build-lib-"+l.name)
 	err = os.Mkdir(dir, 0777)
@@ -108,16 +91,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// 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()
+	args := append(l.cflags(), "-c", "-Oz", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
 	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(args, "-mcpu="+cpu)
 	}
 	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
 		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft")
@@ -132,39 +108,27 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// Create job to put all the object files in a single archive. This archive
 	// file is the (static) library file.
 	var objs []string
+	arpath := filepath.Join(dir, l.name+".a")
 	job = &compileJob{
-		description: "ar " + l.name + "/lib.a",
-		result:      filepath.Join(goenv.Get("GOCACHE"), outname, "lib.a"),
+		description: "ar " + l.name + ".a",
+		result:      arpath,
 		run: func(*compileJob) error {
 			// Create an archive of all object files.
-			f, err := ioutil.TempFile(outdir, "libc.a.tmp*")
-			if err != nil {
-				return err
-			}
-			err = makeArchive(f, objs)
-			if err != nil {
-				return err
-			}
-			err = f.Close()
+			err := makeArchive(arpath, objs)
 			if err != nil {
 				return err
 			}
 			// Store this archive in the cache.
-			return os.Rename(f.Name(), archiveFilePath)
+			_, err = cacheStore(arpath, outfile, l.sourcePaths(target))
+			return err
 		},
 	}

 	// 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) {
+		srcpath := srcpath // avoid concurrency issues by redefining inside the loop
+		objpath := filepath.Join(dir, filepath.Base(srcpath)+".o")
 		objs = append(objs, objpath)
 		job.dependencies = append(job.dependencies, &compileJob{
 			description: "compile " + srcpath,
@@ -181,31 +145,5 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		})
 	}

-	// 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"))
-			},
-		})
-	}
-
 	return job, nil
 }
@@ -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,162 +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",
-		}
-	},
-	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,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",
-			"-Xclang", "-internal-isystem", "-Xclang", 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:
@@ -24,7 +24,7 @@ func runCCompiler(flags ...string) error {
 	}

 	// Compile this with an external invocation of the Clang compiler.
-	return execCommand("clang", flags...)
+	return execCommand(commands["clang"], flags...)
 }

 // link invokes a linker with the given name and flags.
@@ -38,8 +38,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"
@@ -26,19 +25,12 @@ import (
 	"golang.org/x/tools/go/ast/astutil"
 )

-// Version of the cgo package. It must be incremented whenever the cgo package
-// is changed in a way that affects the output so that cached package builds
-// will be invalidated.
-// This version is independent of the TinyGo version number.
-const Version = 1 // last change: run libclang once per Go file
-
 // cgoPackage holds all CGo-related information of a package.
 type cgoPackage struct {
 	generated       *ast.File
 	generatedPos    token.Pos
 	errors          []error
-	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{}
@@ -132,17 +124,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
@@ -163,49 +155,15 @@ 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, 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, map[string][]byte, []error) {
 	p := &cgoPackage{
-		currentDir:      dir,
+		dir:             dir,
 		fset:            fset,
 		tokenFiles:      map[string]*token.File{},
 		missingSymbols:  map[string]struct{}{},
@@ -226,41 +184,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, nil, nil, 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 {
@@ -270,10 +255,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)
@@ -297,40 +281,105 @@ 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)
+	}
+
+	// Find all #cgo lines.
+	for _, genDecl := range statements {
+		if genDecl.Doc == nil {
+			continue
+		}
+		for _, comment := range genDecl.Doc.List {
+			for {
+				// Extract the #cgo line, and replace it with spaces.
+				// Replacing with spaces makes sure that error locations are
+				// still correct, while not interfering with parsing in any way.
+				lineStart := strings.Index(comment.Text, "#cgo ")
+				if lineStart < 0 {
+					break
+				}
+				lineLen := strings.IndexByte(comment.Text[lineStart:], '\n')
+				if lineLen < 0 {
+					lineLen = len(comment.Text) - lineStart
+				}
+				lineEnd := lineStart + lineLen
+				line := comment.Text[lineStart:lineEnd]
+				spaces := make([]byte, len(line))
+				for i := range spaces {
+					spaces[i] = ' '
+				}
+				lenBefore := len(comment.Text)
+				comment.Text = comment.Text[:lineStart] + string(spaces) + comment.Text[lineEnd:]
+				if len(comment.Text) != lenBefore {
+					println(lenBefore, len(comment.Text))
+					panic("length of preamble changed!")
+				}
+
+				// Get the text before the colon in the #cgo directive.
+				colon := strings.IndexByte(line, ':')
+				if colon < 0 {
+					p.addErrorAfter(comment.Slash, comment.Text[:lineStart], "missing colon in #cgo line")
+					continue
+				}
+
+				// Extract the fields before the colon. These fields are a list
+				// of build tags and the C environment variable.
+				fields := strings.Fields(line[4:colon])
+				if len(fields) == 0 {
+					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon-1], "invalid #cgo line")
+					continue
+				}
+
+				if len(fields) > 1 {
+					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+5], "not implemented: build constraints in #cgo line")
+					continue
+				}
+
+				name := fields[len(fields)-1]
+				value := line[colon+1:]
+				switch name {
+				case "CFLAGS":
+					flags, err := shlex.Split(value)
+					if err != nil {
+						// TODO: find the exact location where the error happened.
+						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
+						continue
+					}
+					if err := checkCompilerFlags(name, flags); err != nil {
+						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
+						continue
+					}
+					makePathsAbsolute(flags, packagePath)
+					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(comment.Slash, comment.Text[:lineStart+colon+1], "failed to parse flags in #cgo line: "+err.Error())
+						continue
+					}
+					if err := checkLinkerFlags(name, flags); err != nil {
+						p.addErrorAfter(comment.Slash, comment.Text[:lineStart+colon+1], err.Error())
+						continue
+					}
+					makePathsAbsolute(flags, packagePath)
+					p.ldflags = append(p.ldflags, flags...)
+				default:
+					startPos := strings.LastIndex(line[4:colon], name) + 4
+					p.addErrorAfter(comment.Slash, comment.Text[:lineStart+startPos], "invalid #cgo line: "+name)
+					continue
+				}
+			}
+		}
 	}

 	// Define CFlags that will be used while parsing the package.
@@ -340,9 +389,16 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	cflagsForCGo := append([]string{"-D_FORTIFY_SOURCE=0"}, cflags...)
 	cflagsForCGo = append(cflagsForCGo, p.cflags...)

-	// Process CGo imports for each file.
-	for i, f := range files {
-		p.parseFragment(cgoHeaders[i]+cgoTypes, cflagsForCGo, filepath.Base(fset.File(f.Pos()).Name()))
+	// 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, cflagsForCGo, position.Filename, position.Line)
 	}

 	// Declare functions found by libclang.
@@ -377,18 +433,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.cflags, p.ldflags, p.visitedFiles, p.errors
 }

 // makePathsAbsolute converts some common path compiler flags (-I, -L) from
 // relative flags into absolute flags, if they are relative. This is necessary
 // because the C compiler is usually not invoked from the package path.
-func (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" {
@@ -398,95 +454,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() {
@@ -503,14 +476,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,
@@ -527,16 +492,20 @@ func (p *cgoPackage) addFuncDecls() {
 			},
 		}
 		if fn.variadic {
-			decl.Doc.List = append(decl.Doc.List, &ast.Comment{
-				Slash: fn.pos - 1,
-				Text:  "//go:variadic",
-			})
+			decl.Doc = &ast.CommentGroup{
+				List: []*ast.Comment{
+					&ast.Comment{
+						Slash: fn.pos,
+						Text:  "//go:variadic",
+					},
+				},
+			}
 		}
 		obj.Decl = decl
 		for i, arg := range fn.args {
 			args[i] = &ast.Field{
 				Names: []*ast.Ident{
-					{
+					&ast.Ident{
 						NamePos: fn.pos,
 						Name:    arg.name,
 						Obj: &ast.Object{
@@ -584,7 +553,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,
@@ -634,7 +603,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,
@@ -663,27 +632,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,
@@ -884,9 +845,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",
 					},
@@ -967,9 +928,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",
 						},
@@ -998,7 +959,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,
@@ -1077,9 +1038,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{
@@ -1113,7 +1074,7 @@ func (p *cgoPackage) createBitfieldGetter(bitfield bitfieldInfo, typeName string
 			},
 			Results: &ast.FieldList{
 				List: []*ast.Field{
-					{
+					&ast.Field{
 						Type: bitfield.field.Type,
 					},
 				},
@@ -1230,9 +1191,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{
@@ -1263,9 +1224,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,
@@ -12,6 +12,7 @@ import (
 	"go/types"
 	"io/ioutil"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 	"testing"
@@ -24,20 +25,21 @@ var flagUpdate = flag.Bool("update", false, "Update images based on test output.
 // platforms and Go versions.
 func normalizeResult(result string) string {
 	actual := strings.ReplaceAll(result, "\r\n", "\n")
+
+	// 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.
@@ -63,7 +65,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 +105,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")
@@ -16,7 +16,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>

@@ -72,14 +72,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))

@@ -193,14 +196,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),
 					},
 				},
@@ -377,7 +380,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 +391,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 +775,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,12 +796,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
 }
@@ -1,5 +1,5 @@
 // +build !byollvm
-// +build !llvm12
+// +build !llvm10

 package cgo

@@ -0,0 +1,14 @@
+// +build !byollvm
+// +build llvm10
+
+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,14 +0,0 @@
-// +build !byollvm
-// +build llvm12
-
-package cgo
-
-/*
-#cgo linux   CFLAGS:  -I/usr/lib/llvm-12/include
-#cgo darwin  CFLAGS:  -I/usr/local/opt/llvm@12/include
-#cgo freebsd CFLAGS:  -I/usr/local/llvm12/include
-#cgo linux   LDFLAGS: -L/usr/lib/llvm-12/lib -lclang
-#cgo darwin  LDFLAGS: -L/usr/local/opt/llvm@12/lib -lclang -lffi
-#cgo freebsd LDFLAGS: -L/usr/local/llvm12/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

 // 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: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

 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
@@ -9,26 +9,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
@@ -104,11 +104,11 @@ typedef struct {
 	unsigned char e : 3;
 	// Note that C++ allows bitfields bigger than the underlying type.
 } bitfield_t;
-*/
-import "C"

-// // Test that we can refer from this CGo fragment to the fragment above.
-// typedef myint myint2;
+// Function signatures.
+void variadic0();
+void variadic2(int x, int y, ...);
+*/
 import "C"

 var (
@@ -167,3 +167,9 @@ func accessUnion() {
 	var _ *C.int = union2d.unionfield_i()
 	var _ *[2]float64 = union2d.unionfield_d()
 }
+
+// Test function signatures.
+func accessFunctions() {
+	C.variadic0()
+	C.variadic2(3, 5)
+}
@@ -4,25 +4,10 @@ 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))
-}
+func C.variadic0() //go:variadic
+func C.variadic2(x C.int, y C.int) //go:variadic
+var C.variadic0$funcaddr unsafe.Pointer
+var C.variadic2$funcaddr unsafe.Pointer

 const C.option2A = 20
 const C.optionA = 0
@@ -82,7 +67,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 +105,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 +138,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,7 +5,6 @@ package compileopts
 import (
 	"errors"
 	"fmt"
-	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -22,7 +21,7 @@ type Config struct {
 	TestConfig     TestConfig
 }

-// Triple returns the LLVM target triple, like armv6m-unknown-unknown-eabi.
+// Triple returns the LLVM target triple, like armv6m-none-eabi.
 func (c *Config) Triple() string {
 	return c.Target.Triple
 }
@@ -34,16 +33,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 +53,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(), "serial." + c.Serial()}...)
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
@@ -163,7 +150,7 @@ func (c *Config) OptLevels() (optLevel, sizeLevel int, inlinerThreshold uint) {
 // target.
 func (c *Config) FuncImplementation() string {
 	switch c.Scheduler() {
-	case "tasks", "asyncify":
+	case "tasks":
 		// 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
@@ -210,39 +197,6 @@ func (c *Config) RP2040BootPatch() bool {
 	return false
 }

-// MuslArchitecture returns the architecture name as used in musl libc. It is
-// usually the same as the first part of the LLVM triple, but not always.
-func MuslArchitecture(triple string) string {
-	arch := strings.Split(triple, "-")[0]
-	if strings.HasPrefix(arch, "arm") || strings.HasPrefix(arch, "thumb") {
-		arch = "arm"
-	}
-	return arch
-}
-
-// LibcPath returns the path to the libc directory. The libc path will be either
-// a precompiled libc shipped with a TinyGo build, or a libc path in the cache
-// directory (which might not yet be built).
-func (c *Config) LibcPath(name string) (path string, precompiled bool) {
-	// Try to load a precompiled library.
-	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", c.Triple(), name)
-	if _, err := os.Stat(precompiledDir); err == nil {
-		// Found a precompiled library for this OS/architecture. Return the path
-		// directly.
-		return precompiledDir, true
-	}
-
-	// No precompiled library found. Determine the path name that will be used
-	// in the build cache.
-	var outname string
-	if c.CPU() != "" {
-		outname = name + "-" + c.Triple() + "-" + c.CPU()
-	} else {
-		outname = name + "-" + c.Triple()
-	}
-	return filepath.Join(goenv.Get("GOCACHE"), outname), false
-}
-
 // CFlags returns the flags to pass to the C compiler. This is necessary for CGo
 // preprocessing.
 func (c *Config) CFlags() []string {
@@ -250,62 +204,13 @@ func (c *Config) CFlags() []string {
 	for _, flag := range c.Target.CFlags {
 		cflags = append(cflags, strings.ReplaceAll(flag, "{root}", goenv.Get("TINYGOROOT")))
 	}
-	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,
-			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(picolibcDir, "include"),
-			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(picolibcDir, "tinystdio"),
-		)
-	case "musl":
-		root := goenv.Get("TINYGOROOT")
-		path, _ := c.LibcPath("musl")
-		arch := MuslArchitecture(c.Triple())
-		cflags = append(cflags,
-			"--sysroot="+path,
-			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "musl", "arch", arch),
-			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "musl", "include"),
-		)
-	case "wasi-libc":
-		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags, "--sysroot="+root+"/lib/wasi-libc/sysroot")
-	case "mingw-w64":
-		root := goenv.Get("TINYGOROOT")
-		path, _ := c.LibcPath("mingw-w64")
-		cflags = append(cflags,
-			"--sysroot="+path,
-			"-Xclang", "-internal-isystem", "-Xclang", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "crt"),
-			"-Xclang", "-internal-isystem", "-Xclang", 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)
+		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"))
 	}
-	// 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)
-		}
+	if c.Debug() {
+		cflags = append(cflags, "-g")
 	}
 	return cflags
 }
@@ -345,9 +250,8 @@ 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
 }
@@ -393,9 +297,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.
@@ -462,6 +363,10 @@ func (c *Config) WasmAbi() string {
 	return c.Target.WasmAbi
 }

+func (c *Config) LLVMFeatures() string {
+	return c.Options.LLVMFeatures
+}
+
 type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc
@@ -8,7 +8,7 @@ import (

 var (
 	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
-	validSchedulerOptions     = []string{"none", "tasks", "coroutines", "asyncify"}
+	validSchedulerOptions     = []string{"none", "tasks", "coroutines"}
 	validSerialOptions        = []string{"none", "uart", "usb"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
 	validPanicStrategyOptions = []string{"print", "trap"}
@@ -16,12 +16,8 @@ var (
 )

 // 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
@@ -32,7 +28,6 @@ type Options struct {
 	DumpSSA         bool
 	VerifyIR        bool
 	PrintCommands   func(cmd string, args ...string)
-	Parallelism     int // -p flag
 	Debug           bool
 	PrintSizes      string
 	PrintAllocs     *regexp.Regexp // regexp string
@@ -10,7 +10,7 @@ import (
 func TestVerifyOptions(t *testing.T) {

 	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, extalloc, conservative`)
-	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, coroutines, asyncify`)
+	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, coroutines`)
 	expectedPrintSizeError := errors.New(`invalid size option 'incorrect': valid values are none, short, full`)
 	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)

@@ -5,18 +5,15 @@ 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,7 +25,7 @@ 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"`
@@ -97,7 +94,7 @@ func (spec *TargetSpec) overrideProperties(child *TargetSpec) {
 					dst.Set(src)
 				case "append", "":
 					// or append the field of child to spec
-					dst.Set(reflect.AppendSlice(dst, src))
+					dst.Set(reflect.AppendSlice(src, dst))
 				default:
 					panic("override mode must be 'copy' or 'append' (default). I don't know how to '" + tag + "'.")
 				}
@@ -164,78 +161,84 @@ func (spec *TargetSpec) resolveInherits() error {
 }

 // 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",
+			"i686":    "386",
+			"x86_64":  "amd64",
+			"aarch64": "arm64",
+			"armv7":   "arm",
+		}[tripleSplit[0]]
+		if goarch == "" {
+			goarch = tripleSplit[0]
+		}
+		return defaultTarget(goos, goarch, strings.Join(tripleSplit, "-"))
 	}
-	// Successfully loaded this target from a built-in .json file. Make sure
-	// it includes all parents as specified in the "inherits" key.
-	err = spec.resolveInherits()
-	if err != nil {
-		return nil, err
-	}
-
-	if spec.Scheduler == "asyncify" {
-		spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_asyncify_wasm.S")
-	}
-
-	return spec, nil
 }

+// WindowsBuildNotSupportedErr is being thrown, when goos is windows and no target has been specified.
+var WindowsBuildNotSupportedErr = errors.New("Building Windows binaries is currently not supported. Try specifying a different target")
+
 func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
+	if goos == "windows" {
+		return nil, WindowsBuildNotSupportedErr
+	}
 	// No target spec available. Use the default one, useful on most systems
 	// with a regular OS.
 	spec := TargetSpec{
@@ -246,86 +249,36 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		Scheduler:        "tasks",
 		Linker:           "cc",
 		DefaultStackSize: 1024 * 64, // 64kB
+		CFlags:           []string{"--target=" + triple},
 		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"
-		switch strings.Split(triple, "-")[0] {
-		case "armv5":
-			spec.Features = "+armv5t,+strict-align,-thumb-mode"
-		case "armv6":
-			spec.Features = "+armv6,+dsp,+fp64,+strict-align,+vfp2,+vfp2sp,-thumb-mode"
-		case "armv7":
-			spec.Features = "+armv7-a,+d32,+dsp,+fp64,+neon,+vfp2,+vfp2sp,+vfp3,+vfp3d16,+vfp3d16sp,+vfp3sp,-thumb-mode"
-		}
-	case "arm64":
-		spec.CPU = "generic"
-		spec.Features = "+neon"
-	}
 	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")
+		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/gc_"+goarch+".S")
+		spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_stack_"+goarch+".S")
 	}
 	if goarch != runtime.GOARCH {
 		// Some educated guesses as to how to invoke helper programs.
 		spec.GDB = []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.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.Emulator = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
 		}
-	}
-	if goos != runtime.GOOS {
-		if goos == "windows" {
-			spec.Emulator = []string{"wine"}
+		if goarch == "386" && runtime.GOARCH == "amd64" {
+			spec.CFlags = append(spec.CFlags, "-m32")
+			spec.LDFlags = append(spec.LDFlags, "-m32")
 		}
 	}
 	return &spec, nil
@@ -1,23 +1,22 @@
 package compileopts

 import (
-	"os"
 	"reflect"
 	"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)
 	}
 }
@@ -27,7 +26,7 @@ func TestOverrideProperties(t *testing.T) {
 	base := &TargetSpec{
 		GOOS:             "baseGoos",
 		CPU:              "baseCpu",
-		CFlags:           []string{"-base-foo", "-base-bar"},
+		Features:         []string{"bf1", "bf2"},
 		BuildTags:        []string{"bt1", "bt2"},
 		Emulator:         []string{"be1", "be2"},
 		DefaultStackSize: 42,
@@ -37,7 +36,7 @@ func TestOverrideProperties(t *testing.T) {
 	child := &TargetSpec{
 		GOOS:             "",
 		CPU:              "chlidCpu",
-		CFlags:           []string{"-child-foo", "-child-bar"},
+		Features:         []string{"cf1", "cf2"},
 		Emulator:         []string{"ce1", "ce2"},
 		AutoStackSize:    &childAutoStackSize,
 		DefaultStackSize: 64,
@@ -51,8 +50,8 @@ func TestOverrideProperties(t *testing.T) {
 	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.Features, []string{"cf1", "cf2", "bf1", "bf2"}) {
+		t.Errorf("Overriding failed : got %v", base.Features)
 	}
 	if !reflect.DeepEqual(base.BuildTags, []string{"bt1", "bt2"}) {
 		t.Errorf("Overriding failed : got %v", base.BuildTags)
@@ -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.
@@ -214,19 +206,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 +234,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
-}
@@ -38,10 +38,11 @@ func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
 		old := b.getValue(call.Args[1])
 		newVal := b.getValue(call.Args[2])
 		if strings.HasSuffix(name, "64") {
-			if strings.HasPrefix(b.Triple, "thumb") {
+			arch := strings.Split(b.Triple, "-")[0]
+			if strings.HasPrefix(arch, "arm") && strings.HasSuffix(arch, "m") {
 				// Work around a bug in LLVM, at least LLVM 11:
 				// https://reviews.llvm.org/D95891
-				// Check for thumbv6m, thumbv7, thumbv7em, and perhaps others.
+				// Check for armv6m, armv7, armv7em, 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() {
@@ -63,10 +63,10 @@ func (c *compilerContext) expandFormalParamType(t llvm.Type, name string, goType
 	case llvm.StructTypeKind:
 		fieldInfos := c.flattenAggregateType(t, name, goType)
 		if len(fieldInfos) <= maxFieldsPerParam {
-			// managed to expand this parameter
 			return fieldInfos
+		} else {
+			// failed to lower
 		}
-		// failed to expand this parameter: too many fields
 	}
 	// TODO: split small arrays
 	return []paramInfo{
@@ -32,15 +32,8 @@ 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)
-	}
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")
+	b.CreateStore(chanValue, valueAlloca)

 	// Allocate blockedlist buffer.
 	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
@@ -53,9 +46,7 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 	// This also works around a bug in CoroSplit, at least in LLVM 8:
 	// https://bugs.llvm.org/show_bug.cgi?id=41742
 	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
-	if !isZeroSize {
-		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
-	}
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 }

 // createChanRecv emits a pseudo chan receive operation. It is lowered to the
@@ -65,14 +56,7 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 	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")
-	}
+	valueAlloca, valueAllocaCast, valueAllocaSize := b.createTemporaryAlloca(valueType, "chan.value")

 	// Allocate blockedlist buffer.
 	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
@@ -80,14 +64,9 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.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)
-	}
+	received := b.CreateLoad(valueAlloca, "chan.received")
 	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
+	b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)

 	if unop.CommaOk {
 		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false))
@@ -137,6 +116,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 {
@@ -153,6 +133,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 			if align := b.targetData.ABITypeAlignment(llvmType); align > recvbufAlign {
 				recvbufAlign = align
 			}
+			hasReceives = true
 		case types.SendOnly:
 			// Store this value in an alloca and put a pointer to this alloca
 			// in the send state.
@@ -169,7 +150,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)
@@ -23,7 +23,7 @@ import (
 // Version of the compiler pacakge. Must be incremented each time the compiler
 // package changes in a way that affects the generated LLVM module.
 // This version is independent of the TinyGo version number.
-const Version = 25 // last change: add "target-cpu" and "target-features" attributes
+const Version = 12 // last change: implement syscall.rawSyscallNoError

 func init() {
 	llvm.InitializeAllTargets()
@@ -33,6 +33,9 @@ func init() {
 	llvm.InitializeAllAsmPrinters()
 }

+// The TinyGo import path.
+const tinygoPath = "github.com/tinygo-org/tinygo"
+
 // Config is the configuration for the compiler. Most settings should be copied
 // directly from compileopts.Config, it recreated here to decouple the compiler
 // package a bit and because it makes caching easier.
@@ -43,12 +46,11 @@ type Config struct {
 	// Target and output information.
 	Triple          string
 	CPU             string
-	Features        string
+	Features        []string
 	GOOS            string
 	GOARCH          string
 	CodeModel       string
 	RelocationModel string
-	SizeLevel       int

 	// Various compiler options that determine how code is generated.
 	Scheduler          string
@@ -57,6 +59,7 @@ type Config struct {
 	DefaultStackSize   uint64
 	NeedsStackObjects  bool
 	Debug              bool // Whether to emit debug information in the LLVM module.
+	LLVMFeatures       string
 }

 // compilerContext contains function-independent data that should still be
@@ -71,18 +74,15 @@ type compilerContext struct {
 	cu               llvm.Metadata
 	difiles          map[string]llvm.Metadata
 	ditypes          map[types.Type]llvm.Metadata
-	llvmTypes        map[types.Type]llvm.Type
 	machine          llvm.TargetMachine
 	targetData       llvm.TargetData
 	intType          llvm.Type
 	i8ptrType        llvm.Type // for convenience
-	rawVoidFuncType  llvm.Type // for convenience
 	funcPtrAddrSpace int
 	uintptrType      llvm.Type
 	program          *ssa.Program
 	diagnostics      []error
 	astComments      map[string]*ast.CommentGroup
-	pkg              *types.Package
 	runtimePkg       *types.Package
 }

@@ -94,7 +94,6 @@ func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *C
 		DumpSSA:     dumpSSA,
 		difiles:     make(map[string]llvm.Metadata),
 		ditypes:     make(map[types.Type]llvm.Metadata),
-		llvmTypes:   make(map[types.Type]llvm.Type),
 		machine:     machine,
 		targetData:  machine.CreateTargetData(),
 		astComments: map[string]*ast.CommentGroup{},
@@ -123,7 +122,6 @@ func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *C
 	dummyFuncType := llvm.FunctionType(c.ctx.VoidType(), nil, false)
 	dummyFunc := llvm.AddFunction(c.mod, "tinygo.dummy", dummyFuncType)
 	c.funcPtrAddrSpace = dummyFunc.Type().PointerAddressSpace()
-	c.rawVoidFuncType = dummyFunc.Type()
 	dummyFunc.EraseFromParentAsFunction()

 	return c
@@ -141,6 +139,7 @@ type builder struct {
 	blockExits        map[*ssa.BasicBlock]llvm.BasicBlock // these are the exit blocks
 	currentBlock      *ssa.BasicBlock
 	phis              []phiNode
+	taskHandle        llvm.Value
 	deferPtr          llvm.Value
 	difunc            llvm.Metadata
 	dilocals          map[*types.Var]llvm.Metadata
@@ -188,6 +187,12 @@ func NewTargetMachine(config *Config) (llvm.TargetMachine, error) {
 		return llvm.TargetMachine{}, err
 	}

+	feat := config.Features
+	if len(config.LLVMFeatures) > 0 {
+		feat = append(feat, config.LLVMFeatures)
+	}
+	features := strings.Join(feat, ",")
+
 	var codeModel llvm.CodeModel
 	var relocationModel llvm.RelocMode

@@ -215,7 +220,7 @@ func NewTargetMachine(config *Config) (llvm.TargetMachine, error) {
 		relocationModel = llvm.RelocDynamicNoPic
 	}

-	machine := target.CreateTargetMachine(config.Triple, config.CPU, config.Features, llvm.CodeGenLevelDefault, relocationModel, codeModel)
+	machine := target.CreateTargetMachine(config.Triple, config.CPU, features, llvm.CodeGenLevelDefault, relocationModel, codeModel)
 	return machine, nil
 }

@@ -226,6 +231,10 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 	targetData := machine.CreateTargetData()
 	defer targetData.Dispose()

+	intPtrType := targetData.IntPtrType()
+	if intPtrType.IntTypeWidth()/8 <= 32 {
+	}
+
 	var intWidth int
 	if targetData.PointerSize() <= 4 {
 		// 8, 16, 32 bits targets
@@ -240,14 +249,13 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 	return &stdSizes{
 		IntSize:  int64(intWidth / 8),
 		PtrSize:  int64(targetData.PointerSize()),
-		MaxAlign: int64(targetData.PrefTypeAlignment(targetData.IntPtrType())),
+		MaxAlign: int64(targetData.PrefTypeAlignment(intPtrType)),
 	}
 }

 // CompilePackage compiles a single package to a LLVM module.
 func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package, machine llvm.TargetMachine, config *Config, dumpSSA bool) (llvm.Module, []error) {
 	c := newCompilerContext(moduleName, machine, config, dumpSSA)
-	c.pkg = pkg.Pkg
 	c.runtimePkg = ssaPkg.Prog.ImportedPackage("runtime").Pkg
 	c.program = ssaPkg.Prog

@@ -281,14 +289,14 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	if c.Debug {
 		c.mod.AddNamedMetadataOperand("llvm.module.flags",
 			c.ctx.MDNode([]llvm.Metadata{
-				llvm.ConstInt(c.ctx.Int32Type(), 2, false).ConstantAsMetadata(), // Warning on mismatch
+				llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(), // Error on mismatch
 				c.ctx.MDString("Debug Info Version"),
 				llvm.ConstInt(c.ctx.Int32Type(), 3, false).ConstantAsMetadata(), // DWARF version
 			}),
 		)
 		c.mod.AddNamedMetadataOperand("llvm.module.flags",
 			c.ctx.MDNode([]llvm.Metadata{
-				llvm.ConstInt(c.ctx.Int32Type(), 7, false).ConstantAsMetadata(), // Max on mismatch
+				llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(),
 				c.ctx.MDString("Dwarf Version"),
 				llvm.ConstInt(c.ctx.Int32Type(), 4, false).ConstantAsMetadata(),
 			}),
@@ -307,23 +315,10 @@ func (c *compilerContext) getLLVMRuntimeType(name string) llvm.Type {
 	return c.getLLVMType(typ)
 }

-// getLLVMType returns a LLVM type for a Go type. It doesn't recreate already
-// created types. This is somewhat important for performance, but especially
-// important for named struct types (which should only be created once).
+// getLLVMType creates and returns a LLVM type for a Go type. In the case of
+// named struct types (or Go types implemented as named LLVM structs such as
+// strings) it also creates it first if necessary.
 func (c *compilerContext) getLLVMType(goType types.Type) llvm.Type {
-	// Try to load the LLVM type from the cache.
-	if t, ok := c.llvmTypes[goType]; ok {
-		return t
-	}
-	// Not already created, so adding this type to the cache.
-	llvmType := c.makeLLVMType(goType)
-	c.llvmTypes[goType] = llvmType
-	return llvmType
-}
-
-// makeLLVMType creates a LLVM type for a Go type. Don't call this, use
-// getLLVMType instead.
-func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 	switch typ := goType.(type) {
 	case *types.Array:
 		elemType := c.getLLVMType(typ.Elem())
@@ -372,10 +367,12 @@ func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 			// LLVM. This is because it is otherwise impossible to create
 			// self-referencing types such as linked lists.
 			llvmName := typ.Obj().Pkg().Path() + "." + typ.Obj().Name()
-			llvmType := c.ctx.StructCreateNamed(llvmName)
-			c.llvmTypes[goType] = llvmType // avoid infinite recursion
-			underlying := c.getLLVMType(st)
-			llvmType.StructSetBody(underlying.StructElementTypes(), false)
+			llvmType := c.mod.GetTypeByName(llvmName)
+			if llvmType.IsNil() {
+				llvmType = c.ctx.StructCreateNamed(llvmName)
+				underlying := c.getLLVMType(st)
+				llvmType.StructSetBody(underlying.StructElementTypes(), false)
+			}
 			return llvmType
 		}
 		return c.getLLVMType(typ.Underlying())
@@ -442,7 +439,7 @@ func (c *compilerContext) createDIType(typ types.Type) llvm.Metadata {
 			AlignInBits: uint32(c.targetData.ABITypeAlignment(llvmType)) * 8,
 			ElementType: c.getDIType(typ.Elem()),
 			Subscripts: []llvm.DISubrange{
-				{
+				llvm.DISubrange{
 					Lo:    0,
 					Count: typ.Len(),
 				},
@@ -696,6 +693,7 @@ func (c *compilerContext) getDIFile(filename string) llvm.Metadata {
 // createPackage builds the LLVM IR for all types, methods, and global variables
 // in the given package.
 func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package) {
+	println("called create package:", pkg.Pkg.Name())
 	// Sort by position, so that the order of the functions in the IR matches
 	// the order of functions in the source file. This is useful for testing,
 	// for example.
@@ -761,6 +759,35 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 		case *ssa.Global:
 			// Global variable.
 			info := c.getGlobalInfo(member)
+			// process go:embed pragmas
+			// TODO: skip this if not Go 1.16 or higher
+			if strings.TrimSpace(info.embeds) != "" {
+				embeds, err := parseGoEmbed(info.embeds)
+				if err != nil {
+					c.addError(member.Pos(), `invalid go:embed pragma: `+err.Error())
+					goto getGlobal
+				}
+				importsEmbedPkg := false
+				for _, imprt := range pkg.Pkg.Imports() {
+					if imprt.Name() == "embed" {
+						importsEmbedPkg = true
+						break
+					}
+				}
+				if !importsEmbedPkg {
+					// FIXME: technically the "embed" package needs to be imported in every
+					// *source file* that has a //go:embed pragma... that will always be the
+					// case when referencing embed.FS but not necessarily when a go:embed
+					// pragma is added to a string or []byte.  For now, as long as the embed
+					// package is imported in at least one source file, TinyGo will process
+					// any go:embed pragmas in the entire package.
+					c.addError(member.Pos(), `//go:embed only allowed in Go files that import "embed"`)
+					goto getGlobal
+				}
+				fmt.Printf("file embed found at %v (import: %v): %v\n", info.linkName, importsEmbedPkg, embeds)
+			}
+
+		getGlobal:
 			global := c.getGlobal(member)
 			if !info.extern {
 				global.SetInitializer(llvm.ConstNull(global.Type().ElementType()))
@@ -769,29 +796,7 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 					global.SetSection(info.section)
 				}
 			}
-		}
-	}

-	// Add forwarding functions for functions that would otherwise be
-	// implemented in assembly.
-	for _, name := range members {
-		member := pkg.Members[name]
-		switch member := member.(type) {
-		case *ssa.Function:
-			if member.Blocks != nil {
-				continue // external function
-			}
-			info := c.getFunctionInfo(member)
-			if aliasName, ok := stdlibAliases[info.linkName]; ok {
-				alias := c.mod.NamedFunction(aliasName)
-				if alias.IsNil() {
-					// Shouldn't happen, but perhaps best to just ignore.
-					// The error will be a link error, if there is an error.
-					continue
-				}
-				b := newBuilder(c, irbuilder, member)
-				b.createAlias(alias)
-			}
 		}
 	}
 }
@@ -812,7 +817,6 @@ func (b *builder) createFunction() {
 		b.addError(b.fn.Pos(), errValue)
 		return
 	}
-	b.addStandardDefinedAttributes(b.llvmFn)
 	if !b.info.exported {
 		b.llvmFn.SetVisibility(llvm.HiddenVisibility)
 		b.llvmFn.SetUnnamedAddr(true)
@@ -839,17 +843,6 @@ func (b *builder) createFunction() {
 		b.llvmFn.AddFunctionAttr(noinline)
 	}

-	if b.info.interrupt {
-		// Mark this function as an interrupt.
-		// This is necessary on MCUs that don't push caller saved registers when
-		// entering an interrupt, such as on AVR.
-		if strings.HasPrefix(b.Triple, "avr") {
-			b.llvmFn.AddFunctionAttr(b.ctx.CreateStringAttribute("signal", ""))
-		} else {
-			b.addError(b.fn.Pos(), "//go:interrupt not supported on this architecture")
-		}
-	}
-
 	// Add debug info, if needed.
 	if b.Debug {
 		if b.fn.Synthetic == "package initializer" {
@@ -1308,38 +1301,6 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 	case "ssa:wrapnilchk":
 		// TODO: do an actual nil check?
 		return argValues[0], nil
-
-	// Builtins from the unsafe package.
-	case "Add": // unsafe.Add
-		// This is basically just a GEP operation.
-		// Note: the pointer is always of type *i8.
-		ptr := argValues[0]
-		len := argValues[1]
-		return b.CreateGEP(ptr, []llvm.Value{len}, ""), nil
-	case "Slice": // unsafe.Slice
-		// This creates a slice from a pointer and a length.
-		// Note that the exception mentioned in the documentation (if the
-		// pointer and length are nil, the slice is also nil) is trivially
-		// already the case.
-		ptr := argValues[0]
-		len := argValues[1]
-		slice := llvm.Undef(b.ctx.StructType([]llvm.Type{
-			ptr.Type(),
-			b.uintptrType,
-			b.uintptrType,
-		}, false))
-		b.createUnsafeSliceCheck(ptr, len, argTypes[1].Underlying().(*types.Basic))
-		if len.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
-			// Too small, zero-extend len.
-			len = b.CreateZExt(len, b.uintptrType, "")
-		} else if len.Type().IntTypeWidth() > b.uintptrType.IntTypeWidth() {
-			// Too big, truncate len.
-			len = b.CreateTrunc(len, b.uintptrType, "")
-		}
-		slice = b.CreateInsertValue(slice, ptr, 0, "")
-		slice = b.CreateInsertValue(slice, len, 1, "")
-		slice = b.CreateInsertValue(slice, len, 2, "")
-		return slice, nil
 	default:
 		return llvm.Value{}, b.makeError(pos, "todo: builtin: "+callName)
 	}
@@ -1351,9 +1312,9 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 //
 // This is also where compiler intrinsics are implemented.
 func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error) {
-	var params []llvm.Value
-	for _, param := range instr.Args {
-		params = append(params, b.getValue(param))
+	if instr.IsInvoke() {
+		fnCast, args := b.getInvokeCall(instr)
+		return b.createCall(fnCast, args, ""), nil
 	}

 	// Try to call the function directly for trivially static calls.
@@ -1368,11 +1329,6 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.createMemoryCopyCall(fn, instr.Args)
 		case name == "runtime.memzero":
 			return b.createMemoryZeroCall(instr.Args)
-		case name == "math.Ceil" || name == "math.Floor" || name == "math.Sqrt" || name == "math.Trunc":
-			result, ok := b.createMathOp(instr)
-			if ok {
-				return result, nil
-			}
 		case name == "device.Asm" || name == "device/arm.Asm" || name == "device/arm64.Asm" || name == "device/avr.Asm" || name == "device/riscv.Asm":
 			return b.createInlineAsm(instr.Args)
 		case name == "device.AsmFull" || name == "device/arm.AsmFull" || name == "device/arm64.AsmFull" || name == "device/avr.AsmFull" || name == "device/riscv.AsmFull":
@@ -1424,20 +1380,12 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 	} else if call, ok := instr.Value.(*ssa.Builtin); ok {
 		// Builtin function (append, close, delete, etc.).)
 		var argTypes []types.Type
+		var argValues []llvm.Value
 		for _, arg := range instr.Args {
 			argTypes = append(argTypes, arg.Type())
+			argValues = append(argValues, b.getValue(arg))
 		}
-		return b.createBuiltin(argTypes, params, call.Name(), instr.Pos())
-	} else if instr.IsInvoke() {
-		// Interface method call (aka invoke call).
-		itf := b.getValue(instr.Value) // interface value (runtime._interface)
-		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
-		value := b.CreateExtractValue(itf, 1, "invoke.func.value") // receiver
-		// Prefix the params with receiver value and suffix with typecode.
-		params = append([]llvm.Value{value}, params...)
-		params = append(params, typecode)
-		callee = b.getInvokeFunction(instr)
-		context = llvm.Undef(b.i8ptrType)
+		return b.createBuiltin(argTypes, argValues, call.Name(), instr.Pos())
 	} else {
 		// Function pointer.
 		value := b.getValue(instr.Value)
@@ -1447,6 +1395,11 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		b.createNilCheck(instr.Value, callee, "fpcall")
 	}

+	var params []llvm.Value
+	for _, param := range instr.Args {
+		params = append(params, b.getValue(param))
+	}
+
 	if !exported {
 		// This function takes a context parameter.
 		// Add it to the end of the parameter list.
@@ -1464,7 +1417,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 func (b *builder) getValue(expr ssa.Value) llvm.Value {
 	switch expr := expr.(type) {
 	case *ssa.Const:
-		return b.createConst(expr)
+		return b.createConst(b.info.linkName, expr)
 	case *ssa.Function:
 		if b.getFunctionInfo(expr).exported {
 			b.addError(expr.Pos(), "cannot use an exported function as value: "+expr.String())
@@ -1489,28 +1442,6 @@ func (b *builder) getValue(expr ssa.Value) llvm.Value {
 	}
 }

-// maxSliceSize determines the maximum size a slice of the given element type
-// can be.
-func (c *compilerContext) maxSliceSize(elementType llvm.Type) uint64 {
-	// Calculate ^uintptr(0), which is the max value that fits in uintptr.
-	maxPointerValue := llvm.ConstNot(llvm.ConstInt(c.uintptrType, 0, false)).ZExtValue()
-	// Calculate (^uint(0))/2, which is the max value that fits in an int.
-	maxIntegerValue := llvm.ConstNot(llvm.ConstInt(c.intType, 0, false)).ZExtValue() / 2
-
-	// Determine the maximum allowed size for a slice. The biggest possible
-	// pointer (starting from 0) would be maxPointerValue*sizeof(elementType) so
-	// divide by the element type to get the real maximum size.
-	maxSize := maxPointerValue / c.targetData.TypeAllocSize(elementType)
-
-	// len(slice) is an int. Make sure the length remains small enough to fit in
-	// an int.
-	if maxSize > maxIntegerValue {
-		maxSize = maxIntegerValue
-	}
-
-	return maxSize
-}
-
 // createExpr translates a Go SSA expression to LLVM IR. This can be zero, one,
 // or multiple LLVM IR instructions and/or runtime calls.
 func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
@@ -1531,8 +1462,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 				return llvm.Value{}, b.makeError(expr.Pos(), fmt.Sprintf("value is too big (%v bytes)", size))
 			}
 			sizeValue := llvm.ConstInt(b.uintptrType, size, false)
-			layoutValue := b.createObjectLayout(typ, expr.Pos())
-			buf := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, layoutValue}, expr.Comment)
+			buf := b.createRuntimeCall("alloc", []llvm.Value{sizeValue}, expr.Comment)
 			buf = b.CreateBitCast(buf, llvm.PointerType(typ, 0), "")
 			return buf, nil
 		} else {
@@ -1622,14 +1552,10 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		array := b.getValue(expr.X)
 		index := b.getValue(expr.Index)

-		// Extend index to at least uintptr size, because getelementptr assumes
-		// index is a signed integer.
-		index = b.extendInteger(index, expr.Index.Type(), b.uintptrType)
-
 		// Check bounds.
 		arrayLen := expr.X.Type().Underlying().(*types.Array).Len()
 		arrayLenLLVM := llvm.ConstInt(b.uintptrType, uint64(arrayLen), false)
-		b.createLookupBoundsCheck(arrayLenLLVM, index)
+		b.createLookupBoundsCheck(arrayLenLLVM, index, expr.Index.Type())

 		// Can't load directly from array (as index is non-constant), so have to
 		// do it using an alloca+gep+load.
@@ -1670,12 +1596,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			return llvm.Value{}, b.makeError(expr.Pos(), "todo: indexaddr: "+ptrTyp.String())
 		}

-		// Make sure index is at least the size of uintptr becuase getelementptr
-		// assumes index is a signed integer.
-		index = b.extendInteger(index, expr.Index.Type(), b.uintptrType)
-
 		// Bounds check.
-		b.createLookupBoundsCheck(buflen, index)
+		b.createLookupBoundsCheck(buflen, index, expr.Index.Type())

 		switch expr.X.Type().Underlying().(type) {
 		case *types.Pointer:
@@ -1699,17 +1621,9 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 				panic("lookup on non-string?")
 			}

-			// Sometimes, the index can be e.g. an uint8 or int8, and we have to
-			// correctly extend that type for two reasons:
-			//  1. The lookup bounds check expects an index of at least uintptr
-			//     size.
-			//  2. getelementptr has signed operands, and therefore s[uint8(x)]
-			//     can be lowered as s[int8(x)]. That would be a bug.
-			index = b.extendInteger(index, expr.Index.Type(), b.uintptrType)
-
 			// Bounds check.
 			length := b.CreateExtractValue(value, 1, "len")
-			b.createLookupBoundsCheck(length, index)
+			b.createLookupBoundsCheck(length, index, expr.Index.Type())

 			// Lookup byte
 			buf := b.CreateExtractValue(value, 0, "")
@@ -1741,8 +1655,10 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		elemSize := b.targetData.TypeAllocSize(llvmElemType)
 		elemSizeValue := llvm.ConstInt(b.uintptrType, elemSize, false)

-		maxSize := b.maxSliceSize(llvmElemType)
-		if elemSize > maxSize {
+		// Calculate (^uintptr(0)) >> 1, which is the max value that fits in
+		// uintptr if uintptr were signed.
+		maxSize := llvm.ConstLShr(llvm.ConstNot(llvm.ConstInt(b.uintptrType, 0, false)), llvm.ConstInt(b.uintptrType, 1, false))
+		if elemSize > maxSize.ZExtValue() {
 			// This seems to be checked by the typechecker already, but let's
 			// check it again just to be sure.
 			return llvm.Value{}, b.makeError(expr.Pos(), fmt.Sprintf("slice element type is too big (%v bytes)", elemSize))
@@ -1751,8 +1667,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		// Bounds checking.
 		lenType := expr.Len.Type().Underlying().(*types.Basic)
 		capType := expr.Cap.Type().Underlying().(*types.Basic)
-		maxSizeValue := llvm.ConstInt(b.uintptrType, maxSize, false)
-		b.createSliceBoundsCheck(maxSizeValue, sliceLen, sliceCap, sliceCap, lenType, capType, capType)
+		b.createSliceBoundsCheck(maxSize, sliceLen, sliceCap, sliceCap, lenType, capType, capType)

 		// Allocate the backing array.
 		sliceCapCast, err := b.createConvert(expr.Cap.Type(), types.Typ[types.Uintptr], sliceCap, expr.Pos())
@@ -1760,8 +1675,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			return llvm.Value{}, err
 		}
 		sliceSize := b.CreateBinOp(llvm.Mul, elemSizeValue, sliceCapCast, "makeslice.cap")
-		layoutValue := b.createObjectLayout(llvmElemType, expr.Pos())
-		slicePtr := b.createRuntimeCall("alloc", []llvm.Value{sliceSize, layoutValue}, "makeslice.buf")
+		slicePtr := b.createRuntimeCall("alloc", []llvm.Value{sliceSize}, "makeslice.buf")
 		slicePtr = b.CreateBitCast(slicePtr, llvm.PointerType(llvmElemType, 0), "makeslice.array")

 		// Extend or truncate if necessary. This is safe as we've already done
@@ -1835,7 +1749,13 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		if expr.Low != nil {
 			lowType = expr.Low.Type().Underlying().(*types.Basic)
 			low = b.getValue(expr.Low)
-			low = b.extendInteger(low, lowType, b.uintptrType)
+			if low.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
+				if lowType.Info()&types.IsUnsigned != 0 {
+					low = b.CreateZExt(low, b.uintptrType, "")
+				} else {
+					low = b.CreateSExt(low, b.uintptrType, "")
+				}
+			}
 		} else {
 			lowType = types.Typ[types.Uintptr]
 			low = llvm.ConstInt(b.uintptrType, 0, false)
@@ -1844,7 +1764,13 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		if expr.High != nil {
 			highType = expr.High.Type().Underlying().(*types.Basic)
 			high = b.getValue(expr.High)
-			high = b.extendInteger(high, highType, b.uintptrType)
+			if high.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
+				if highType.Info()&types.IsUnsigned != 0 {
+					high = b.CreateZExt(high, b.uintptrType, "")
+				} else {
+					high = b.CreateSExt(high, b.uintptrType, "")
+				}
+			}
 		} else {
 			highType = types.Typ[types.Uintptr]
 		}
@@ -1852,7 +1778,13 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		if expr.Max != nil {
 			maxType = expr.Max.Type().Underlying().(*types.Basic)
 			max = b.getValue(expr.Max)
-			max = b.extendInteger(max, maxType, b.uintptrType)
+			if max.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
+				if maxType.Info()&types.IsUnsigned != 0 {
+					max = b.CreateZExt(max, b.uintptrType, "")
+				} else {
+					max = b.CreateSExt(max, b.uintptrType, "")
+				}
+			}
 		} else {
 			maxType = types.Typ[types.Uintptr]
 		}
@@ -1978,17 +1910,6 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		default:
 			return llvm.Value{}, b.makeError(expr.Pos(), "unknown slice type: "+typ.String())
 		}
-	case *ssa.SliceToArrayPointer:
-		// Conversion from a slice to an array pointer, as the name clearly
-		// says. This requires a runtime check to make sure the slice is at
-		// least as big as the array.
-		slice := b.getValue(expr.X)
-		sliceLen := b.CreateExtractValue(slice, 1, "")
-		arrayLen := expr.Type().Underlying().(*types.Pointer).Elem().Underlying().(*types.Array).Len()
-		b.createSliceToArrayPointerCheck(sliceLen, arrayLen)
-		ptr := b.CreateExtractValue(slice, 0, "")
-		ptr = b.CreateBitCast(ptr, b.getLLVMType(expr.Type()), "")
-		return ptr, nil
 	case *ssa.TypeAssert:
 		return b.createTypeAssert(expr), nil
 	case *ssa.UnOp:
@@ -2017,58 +1938,17 @@ func (b *builder) createBinOp(op token.Token, typ, ytyp types.Type, x, y llvm.Va
 				return b.CreateSub(x, y, ""), nil
 			case token.MUL: // *
 				return b.CreateMul(x, y, ""), nil
-			case token.QUO, token.REM: // /, %
-				// Check for a divide by zero. If y is zero, the Go
-				// specification says that a runtime error must be triggered.
-				b.createDivideByZeroCheck(y)
-
+			case token.QUO: // /
 				if signed {
-					// Deal with signed division overflow.
-					// The LLVM LangRef says:
-					//
-					//   Overflow also leads to undefined behavior; this is a
-					//   rare case, but can occur, for example, by doing a
-					//   32-bit division of -2147483648 by -1.
-					//
-					// The Go specification however says this about division:
-					//
-					//   The one exception to this rule is that if the dividend
-					//   x is the most negative value for the int type of x, the
-					//   quotient q = x / -1 is equal to x (and r = 0) due to
-					//   two's-complement integer overflow.
-					//
-					// In other words, in the special case that the lowest
-					// possible signed integer is divided by -1, the result of
-					// the division is the same as x (the dividend).
-					// This is implemented by checking for this condition and
-					// changing y to 1 if it occurs, for example for 32-bit
-					// ints:
-					//
-					//   if x == -2147483648 && y == -1 {
-					//       y = 1
-					//   }
-					//
-					// Dividing x by 1 obviously returns x, therefore satisfying
-					// the Go specification without a branch.
-					llvmType := x.Type()
-					minusOne := llvm.ConstSub(llvm.ConstInt(llvmType, 0, false), llvm.ConstInt(llvmType, 1, false))
-					lowestInteger := llvm.ConstInt(x.Type(), 1<<(llvmType.IntTypeWidth()-1), false)
-					yIsMinusOne := b.CreateICmp(llvm.IntEQ, y, minusOne, "")
-					xIsLowestInteger := b.CreateICmp(llvm.IntEQ, x, lowestInteger, "")
-					hasOverflow := b.CreateAnd(yIsMinusOne, xIsLowestInteger, "")
-					y = b.CreateSelect(hasOverflow, llvm.ConstInt(llvmType, 1, true), y, "")
-
-					if op == token.QUO {
-						return b.CreateSDiv(x, y, ""), nil
-					} else {
-						return b.CreateSRem(x, y, ""), nil
-					}
+					return b.CreateSDiv(x, y, ""), nil
 				} else {
-					if op == token.QUO {
-						return b.CreateUDiv(x, y, ""), nil
-					} else {
-						return b.CreateURem(x, y, ""), nil
-					}
+					return b.CreateUDiv(x, y, ""), nil
+				}
+			case token.REM: // %
+				if signed {
+					return b.CreateSRem(x, y, ""), nil
+				} else {
+					return b.CreateURem(x, y, ""), nil
 				}
 			case token.AND: // &
 				return b.CreateAnd(x, y, ""), nil
@@ -2276,16 +2156,16 @@ func (b *builder) createBinOp(op token.Token, typ, ytyp types.Type, x, y llvm.Va
 			case token.NEQ: // !=
 				result := b.createRuntimeCall("stringEqual", []llvm.Value{x, y}, "")
 				return b.CreateNot(result, ""), nil
-			case token.LSS: // x < y
+			case token.LSS: // <
 				return b.createRuntimeCall("stringLess", []llvm.Value{x, y}, ""), nil
-			case token.LEQ: // x <= y becomes NOT (y < x)
+			case token.LEQ: // <=
 				result := b.createRuntimeCall("stringLess", []llvm.Value{y, x}, "")
 				return b.CreateNot(result, ""), nil
-			case token.GTR: // x > y becomes y < x
-				return b.createRuntimeCall("stringLess", []llvm.Value{y, x}, ""), nil
-			case token.GEQ: // x >= y becomes NOT (x < y)
+			case token.GTR: // >
 				result := b.createRuntimeCall("stringLess", []llvm.Value{x, y}, "")
 				return b.CreateNot(result, ""), nil
+			case token.GEQ: // >=
+				return b.createRuntimeCall("stringLess", []llvm.Value{y, x}, ""), nil
 			default:
 				panic("binop on string: " + op.String())
 			}
@@ -2415,7 +2295,7 @@ func (b *builder) createBinOp(op token.Token, typ, ytyp types.Type, x, y llvm.Va
 }

 // createConst creates a LLVM constant value from a Go constant.
-func (b *builder) createConst(expr *ssa.Const) llvm.Value {
+func (b *builder) createConst(prefix string, expr *ssa.Const) llvm.Value {
 	switch typ := expr.Type().Underlying().(type) {
 	case *types.Basic:
 		llvmType := b.getLLVMType(typ)
@@ -2431,7 +2311,7 @@ func (b *builder) createConst(expr *ssa.Const) llvm.Value {
 			strLen := llvm.ConstInt(b.uintptrType, uint64(len(str)), false)
 			var strPtr llvm.Value
 			if str != "" {
-				objname := b.pkg.Path() + "$string"
+				objname := prefix + "$string"
 				global := llvm.AddGlobal(b.mod, llvm.ArrayType(b.ctx.Int8Type(), len(str)), objname)
 				global.SetInitializer(b.ctx.ConstString(str, false))
 				global.SetLinkage(llvm.InternalLinkage)
@@ -2461,15 +2341,15 @@ func (b *builder) createConst(expr *ssa.Const) llvm.Value {
 			n, _ := constant.Float64Val(expr.Value)
 			return llvm.ConstFloat(llvmType, n)
 		} else if typ.Kind() == types.Complex64 {
-			r := b.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float32]))
-			i := b.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float32]))
+			r := b.createConst(prefix, ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float32]))
+			i := b.createConst(prefix, ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float32]))
 			cplx := llvm.Undef(b.ctx.StructType([]llvm.Type{b.ctx.FloatType(), b.ctx.FloatType()}, false))
 			cplx = b.CreateInsertValue(cplx, r, 0, "")
 			cplx = b.CreateInsertValue(cplx, i, 1, "")
 			return cplx
 		} else if typ.Kind() == types.Complex128 {
-			r := b.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float64]))
-			i := b.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float64]))
+			r := b.createConst(prefix, ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float64]))
+			i := b.createConst(prefix, ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float64]))
 			cplx := llvm.Undef(b.ctx.StructType([]llvm.Type{b.ctx.DoubleType(), b.ctx.DoubleType()}, false))
 			cplx = b.CreateInsertValue(cplx, r, 0, "")
 			cplx = b.CreateInsertValue(cplx, i, 1, "")
@@ -2802,8 +2682,9 @@ func (b *builder) createUnOp(unop *ssa.UnOp) (llvm.Value, error) {
 			//     var C.add unsafe.Pointer
 			// Instead of a load from the global, create a bitcast of the
 			// function pointer itself.
-			name := strings.TrimSuffix(unop.X.(*ssa.Global).Name(), "$funcaddr")
-			fn := b.getFunction(b.fn.Pkg.Members[name].(*ssa.Function))
+			globalName := b.getGlobalInfo(unop.X.(*ssa.Global)).linkName
+			name := globalName[:len(globalName)-len("$funcaddr")]
+			fn := b.getFunction(b.fn.Pkg.Members["C."+name].(*ssa.Function))
 			if fn.IsNil() {
 				return llvm.Value{}, b.makeError(unop.Pos(), "cgo function not found: "+name)
 			}
@@ -9,7 +9,6 @@ import (
 	"testing"

 	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/loader"
 	"tinygo.org/x/go-llvm"
 )
@@ -17,12 +16,6 @@ import (
 // Pass -update to go test to update the output of the test files.
 var flagUpdate = flag.Bool("update", false, "update tests based on test output")

-type testCase struct {
-	file      string
-	target    string
-	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) {
@@ -41,36 +34,20 @@ func TestCompiler(t *testing.T) {
 		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", "", "coroutines"},
-		{"pragma.go", "", ""},
-		{"goroutine.go", "wasm", "asyncify"},
-		{"goroutine.go", "wasm", "coroutines"},
-		{"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", "", ""})
+	tests := []struct {
+		file   string
+		target string
+	}{
+		{"basic.go", ""},
+		{"pointer.go", ""},
+		{"slice.go", ""},
+		{"string.go", ""},
+		{"float.go", ""},
+		{"interface.go", ""},
+		{"func.go", ""},
+		{"pragma.go", ""},
+		{"goroutine.go", "wasm"},
+		{"goroutine.go", "cortex-m-qemu"},
 	}

 	for _, tc := range tests {
@@ -78,25 +55,16 @@ func TestCompiler(t *testing.T) {
 		targetString := "wasm"
 		if tc.target != "" {
 			targetString = tc.target
-			name += "-" + tc.target
-		}
-		if tc.scheduler != "" {
-			name += "-" + tc.scheduler
+			name = tc.file + "-" + tc.target
 		}

 		t.Run(name, func(t *testing.T) {
-			options := &compileopts.Options{
-				Target: targetString,
-			}
-			target, err := compileopts.LoadTarget(options)
+			target, err := compileopts.LoadTarget(targetString)
 			if err != nil {
 				t.Fatal("failed to load target:", err)
 			}
-			if tc.scheduler != "" {
-				options.Scheduler = tc.scheduler
-			}
 			config := &compileopts.Config{
-				Options: options,
+				Options: &compileopts.Options{},
 				Target:  target,
 			}
 			compilerConfig := &Config{
@@ -108,7 +76,6 @@ func TestCompiler(t *testing.T) {
 				Scheduler:          config.Scheduler(),
 				FuncImplementation: config.FuncImplementation(),
 				AutomaticStackSize: config.AutomaticStackSize(),
-				DefaultStackSize:   config.Target.DefaultStackSize,
 			}
 			machine, err := NewTargetMachine(compilerConfig)
 			if err != nil {
@@ -157,9 +124,6 @@ func TestCompiler(t *testing.T) {
 			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.
@@ -207,12 +171,6 @@ func fuzzyEqualIR(s1, s2 string) bool {
 // stripped out.
 func filterIrrelevantIRLines(lines []string) []string {
 	var out []string
-	llvmVersion, err := strconv.Atoi(strings.Split(llvm.Version, ".")[0])
-	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)
-	}
 	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
@@ -222,11 +180,6 @@ func filterIrrelevantIRLines(lines []string) []string {
 		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.
-			continue
-		}
 		out = append(out, line)
 	}
 	return out
@@ -217,8 +217,7 @@ 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 {
@@ -332,10 +331,10 @@ func (b *builder) createRunDefers() {
 				//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)
+				// Isolate the typecode.
+				typecode := forwardParams[0]
+				forwardParams = forwardParams[1:]
+				fnPtr = b.getInvokePtr(callback, typecode)

 				// Add the context parameter. An interface call cannot also be a
 				// closure but we have to supply the parameter anyway for platforms
@@ -0,0 +1,70 @@
+package compiler
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// parseGoEmbed parses the text following "//go:embed" to extract the glob patterns.
+// It accepts unquoted space-separated patterns as well as double-quoted and back-quoted Go strings.
+// Copied from https://github.com/golang/go/blob/219fe9d547d09d3de1b024c6c8b8314dd0bf12e4/src/cmd/compile/internal/noder/noder.go#L1717-L1776
+func parseGoEmbed(args string) ([]string, error) {
+	var list []string
+	for args = strings.TrimSpace(args); args != ""; args = strings.TrimSpace(args) {
+		var path string
+	Switch:
+		switch args[0] {
+		default:
+			i := len(args)
+			for j, c := range args {
+				if unicode.IsSpace(c) {
+					i = j
+					break
+				}
+			}
+			path = args[:i]
+			args = args[i:]
+
+		case '`':
+			i := strings.Index(args[1:], "`")
+			if i < 0 {
+				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
+			}
+			path = args[1 : 1+i]
+			args = args[1+i+1:]
+
+		case '"':
+			i := 1
+			for ; i < len(args); i++ {
+				if args[i] == '\\' {
+					i++
+					continue
+				}
+				if args[i] == '"' {
+					q, err := strconv.Unquote(args[:i+1])
+					if err != nil {
+						return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args[:i+1])
+					}
+					path = q
+					args = args[i+1:]
+					break Switch
+				}
+			}
+			if i >= len(args) {
+				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
+			}
+		}
+
+		if args != "" {
+			r, _ := utf8.DecodeRuneInString(args)
+			if !unicode.IsSpace(r) {
+				return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
+			}
+		}
+		list = append(list, path)
+	}
+	return list, nil
+}
@@ -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 {
@@ -23,7 +23,7 @@ func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context
 	switch c.FuncImplementation {
 	case "doubleword":
 		// Closure is: {context, function pointer}
-		funcValueScalar = llvm.ConstBitCast(funcPtr, c.rawVoidFuncType)
+		funcValueScalar = funcPtr
 	case "switch":
 		funcValueWithSignatureGlobalName := funcPtr.Name() + "$withSignature"
 		funcValueWithSignatureGlobal := c.mod.NamedGlobal(funcValueWithSignatureGlobalName)
@@ -80,21 +80,8 @@ func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (f
 	context = b.CreateExtractValue(funcValue, 0, "")
 	switch b.FuncImplementation {
 	case "doubleword":
-		bitcast := b.CreateExtractValue(funcValue, 1, "")
-		if !bitcast.IsAConstantExpr().IsNil() && bitcast.Opcode() == llvm.BitCast {
-			funcPtr = bitcast.Operand(0)
-			return
-		}
-		llvmSig := b.getRawFuncType(sig)
-		funcPtr = b.CreateBitCast(bitcast, llvmSig, "")
+		funcPtr = b.CreateExtractValue(funcValue, 1, "")
 	case "switch":
-		if !funcValue.IsAConstant().IsNil() {
-			// If this is a constant func value, the underlying function is
-			// known and can be returned directly.
-			funcValueWithSignatureGlobal := llvm.ConstExtractValue(funcValue, []uint32{1}).Operand(0)
-			funcPtr = llvm.ConstExtractValue(funcValueWithSignatureGlobal.Initializer(), []uint32{0}).Operand(0)
-			return
-		}
 		llvmSig := b.getRawFuncType(sig)
 		sigGlobal := b.getFuncSignatureID(sig)
 		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
@@ -109,7 +96,8 @@ func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (f
 func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
 	switch c.FuncImplementation {
 	case "doubleword":
-		return c.ctx.StructType([]llvm.Type{c.i8ptrType, c.rawVoidFuncType}, false)
+		rawPtr := c.getRawFuncType(typ)
+		return c.ctx.StructType([]llvm.Type{c.i8ptrType, rawPtr}, false)
 	case "switch":
 		return c.getLLVMRuntimeType("funcValue")
 	default:
@@ -79,15 +79,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 		}
 		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 {
+	} else if !instr.Call.IsInvoke() {
 		// This is a function pointer.
 		// At the moment, two extra params are passed to the newly started
 		// goroutine:
@@ -100,19 +92,22 @@ func (b *builder) createGo(instr *ssa.Go) {
 		switch b.Scheduler {
 		case "none", "coroutines":
 			// There are no additional parameters needed for the goroutine start operation.
-		case "tasks", "asyncify":
+		case "tasks":
 			// Add the function pointer as a parameter to start the goroutine.
 			params = append(params, funcPtr)
 		default:
 			panic("unknown scheduler type")
 		}
 		prefix = b.fn.RelString(nil)
+	} else {
+		b.addError(instr.Pos(), "todo: go on interface call")
+		return
 	}

 	paramBundle := b.emitPointerPack(params)
 	var callee, stackSize llvm.Value
 	switch b.Scheduler {
-	case "none", "tasks", "asyncify":
+	case "none", "tasks":
 		callee = b.createGoroutineStartWrapper(funcPtr, prefix, hasContext, instr.Pos())
 		if b.AutomaticStackSize {
 			// The stack size is not known until after linking. Call a dummy
@@ -124,7 +119,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 		} 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 {
+			if b.Scheduler == "tasks" && b.DefaultStackSize == 0 {
 				b.addError(instr.Pos(), "default stack size for goroutines is not set")
 			}
 			stackSize = llvm.ConstInt(b.uintptrType, b.DefaultStackSize, false)
@@ -170,11 +165,6 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 	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()
@@ -186,7 +176,6 @@ 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.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", name))
@@ -230,12 +219,6 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		// Create the call.
 		builder.CreateCall(fn, params, "")

-		if c.Scheduler == "asyncify" {
-			builder.CreateCall(deadlock, []llvm.Value{
-				llvm.Undef(c.i8ptrType), llvm.Undef(c.i8ptrType),
-			}, "")
-		}
-
 	} else {
 		// For a function pointer like this:
 		//
@@ -257,7 +240,6 @@ 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.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", ""))
@@ -303,22 +285,11 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri

 		// Create the call.
 		builder.CreateCall(fnPtr, params, "")
-
-		if c.Scheduler == "asyncify" {
-			builder.CreateCall(deadlock, []llvm.Value{
-				llvm.Undef(c.i8ptrType), 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, "")
@@ -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]
@@ -47,7 +47,6 @@ func (c *compilerContext) getTypeCode(typ types.Type) 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())
@@ -70,9 +69,6 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		}
 		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))
@@ -91,9 +87,6 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		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)
@@ -200,11 +193,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] = t.Method(i).Name() + ":" + getTypeCodeName(t.Method(i).Type())
 		}
 		return "interface:" + "{" + strings.Join(methods, ",") + "}"
 	case *types.Map:
@@ -317,9 +306,10 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 	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 {
+// getMethodSignature returns a global variable which is a reference to an
+// external *i8 indicating the indicating the signature of this method. It is
+// used during the interface lowering pass.
+func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
 	signature := methodSignature(method)
 	var globalName string
 	if token.IsExported(method.Name()) {
@@ -327,14 +317,6 @@ func (c *compilerContext) getMethodSignatureName(method *types.Func) string {
 	} 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)
 	if signatureGlobal.IsNil() {
 		// TODO: put something useful in these globals, such as the method
@@ -363,16 +345,15 @@ 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)
@@ -439,52 +420,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
@@ -521,7 +489,6 @@ 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)
 	wrapper.LastParam().SetName("parentHandle")

 	wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
@@ -36,8 +36,6 @@ 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.
@@ -49,9 +47,8 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	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.
@@ -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.NeedsStackObjects, 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)
-	copy(bitmapBytes, bitmap.Bytes())
-	var bitmapByteValues []llvm.Value
-	for _, b := range bitmapBytes {
-		bitmapByteValues = append(bitmapByteValues, llvm.ConstInt(c.ctx.Int8Type(), uint64(b), false))
-	}
-	initializer := c.ctx.ConstStruct([]llvm.Value{
-		llvm.ConstInt(c.uintptrType, objectSizeWords, false),
-		llvm.ConstArray(c.ctx.Int8Type(), bitmapByteValues),
-	}, false)
-
-	global = llvm.AddGlobal(c.mod, initializer.Type(), globalName)
-	global.SetInitializer(initializer)
-	global.SetUnnamedAddr(true)
-	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.LinkOnceODRLinkage)
-	if c.targetData.PrefTypeAlignment(c.uintptrType) < 2 {
-		// AVR doesn't have alignment by default.
-		global.SetAlignment(2)
-	}
-	if c.Debug && pos != token.NoPos {
-		// Creating a fake global so that the value can be inspected in GDB.
-		// For example, the layout for strings.stringFinder (as of Go version
-		// 1.15) has the following type according to GDB:
-		//   type = struct {
-		//       uintptr numBits;
-		//       uint8 data[33];
-		//   }
-		// ...that's sort of a mixed C/Go type, but it is readable. More
-		// importantly, these object layout globals can be read and printed by
-		// GDB which may be useful for debugging.
-		position := c.program.Fset.Position(pos)
-		diglobal := c.dibuilder.CreateGlobalVariableExpression(c.difiles[position.Filename], llvm.DIGlobalVariableExpression{
-			Name: globalName,
-			File: c.getDIFile(position.Filename),
-			Line: position.Line,
-			Type: c.getDIType(types.NewStruct([]*types.Var{
-				types.NewVar(pos, nil, "numBits", types.Typ[types.Uintptr]),
-				types.NewVar(pos, nil, "data", types.NewArray(types.Typ[types.Byte], int64(len(bitmapByteValues)))),
-			}, nil)),
-			LocalToUnit: false,
-			Expr:        c.dibuilder.CreateExpression(nil),
-		})
-		global.AddMetadata(0, diglobal)
-	}
-
-	return llvm.ConstBitCast(global, c.i8ptrType)
-}
-
-// getPointerBitmap scans the given LLVM type for pointers and sets bits in a
-// bigint at the word offset that contains a pointer. This scan is recursive.
-func (c *compilerContext) getPointerBitmap(typ llvm.Type, pos token.Pos) *big.Int {
-	alignment := c.targetData.PrefTypeAlignment(c.i8ptrType)
-	switch typ.TypeKind() {
-	case llvm.IntegerTypeKind, llvm.FloatTypeKind, llvm.DoubleTypeKind:
-		return big.NewInt(0)
-	case llvm.PointerTypeKind:
-		return big.NewInt(1)
-	case llvm.StructTypeKind:
-		ptrs := big.NewInt(0)
-		if typ.StructName() == "runtime.funcValue" {
-			// Hack: the type runtime.funcValue contains an 'id' field which is
-			// of type uintptr, but before the LowerFuncValues pass it actually
-			// contains a pointer (ptrtoint) to a global. This trips up the
-			// interp package. Therefore, make the id field a pointer for now.
-			typ = c.ctx.StructType([]llvm.Type{c.i8ptrType, c.i8ptrType}, false)
-		}
-		for i, subtyp := range typ.StructElementTypes() {
-			subptrs := c.getPointerBitmap(subtyp, pos)
-			if subptrs.BitLen() == 0 {
-				continue
-			}
-			offset := c.targetData.ElementOffset(typ, i)
-			if offset%uint64(alignment) != 0 {
-				// This error will let the compilation fail, but by continuing
-				// the error can still easily be shown.
-				c.addError(pos, "internal error: allocated struct contains unaligned pointer")
-				continue
-			}
-			subptrs.Lsh(subptrs, uint(offset)/uint(alignment))
-			ptrs.Or(ptrs, subptrs)
-		}
-		return ptrs
-	case llvm.ArrayTypeKind:
-		subtyp := typ.ElementType()
-		subptrs := c.getPointerBitmap(subtyp, pos)
-		ptrs := big.NewInt(0)
-		if subptrs.BitLen() == 0 {
-			return ptrs
-		}
-		elementSize := c.targetData.TypeAllocSize(subtyp)
-		if elementSize%uint64(alignment) != 0 {
-			// This error will let the compilation fail (but continues so that
-			// other errors can be shown).
-			c.addError(pos, "internal error: allocated array contains unaligned pointer")
-			return ptrs
-		}
-		for i := 0; i < typ.ArrayLength(); i++ {
-			ptrs.Lsh(ptrs, uint(elementSize)/uint(alignment))
-			ptrs.Or(ptrs, subptrs)
-		}
-		return ptrs
-	default:
-		// Should not happen.
-		panic("unknown LLVM type")
-	}
-}
@@ -12,7 +12,7 @@ import (
 // bitcasts, or else allocates a value on the heap if it cannot be packed in the
 // pointer value directly. It returns the pointer with the packed data.
 // If the values are all constants, they are be stored in a constant global and deduplicated.
-func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needsStackObjects bool, values []llvm.Value) llvm.Value {
+func EmitPointerPack(builder llvm.Builder, mod llvm.Module, needsStackObjects bool, values []llvm.Value) llvm.Value {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
 	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
@@ -83,11 +83,12 @@ 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)
 		}

@@ -96,7 +97,6 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needs
 		alloc := mod.NamedFunction("runtime.alloc")
 		packedHeapAlloc := builder.CreateCall(alloc, []llvm.Value{
 			sizeValue,
-			llvm.ConstNull(i8ptrType),
 			llvm.Undef(i8ptrType),            // unused context parameter
 			llvm.ConstPointerNull(i8ptrType), // coroutine handle
 		}, "")
@@ -26,7 +26,6 @@ type functionInfo struct {
 	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
@@ -109,7 +108,6 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 			llvmFn.AddFunctionAttr(attr)
 		}
 	}
-	c.addStandardDeclaredAttributes(llvmFn)

 	dereferenceableOrNullKind := llvm.AttributeKindID("dereferenceable_or_null")
 	for i, info := range paramInfos {
@@ -208,9 +206,14 @@ 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)
@@ -247,10 +250,6 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {

 				importName = parts[1]
 				info.exported = true
-			case "//go:interrupt":
-				if hasUnsafeImport(f.Pkg.Pkg) {
-					info.interrupt = true
-				}
 			case "//go:wasm-module":
 				// Alternative comment for setting the import module.
 				if len(parts) != 2 {
@@ -324,53 +323,6 @@ func getParams(sig *types.Signature) []*types.Var {
 	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).
@@ -379,6 +331,7 @@ type globalInfo struct {
 	extern   bool   // go:extern
 	align    int    // go:align
 	section  string // go:section
+	embeds   string // go:embed
 }

 // loadASTComments loads comments on globals from the AST, for use later in the
@@ -455,14 +408,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
 }
@@ -490,6 +449,9 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 			if len(parts) == 2 {
 				info.section = parts[1]
 			}
+		case "//go:embed":
+			raw := strings.TrimPrefix(comment.Text, "//go:embed")
+			info.embeds += " " + raw
 		}
 	}
 }
@@ -156,12 +156,12 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 // createSyscall emits instructions for the syscall.Syscall* family of
 // functions, depending on the target OS/arch.
 func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
+	syscallResult, err := b.createRawSyscall(call)
+	if err != nil {
+		return syscallResult, err
+	}
 	switch b.GOOS {
-	case "linux":
-		syscallResult, err := b.createRawSyscall(call)
-		if err != nil {
-			return syscallResult, err
-		}
+	case "linux", "freebsd":
 		// Return values: r0, r1 uintptr, err Errno
 		// Pseudocode:
 		//     var err uintptr
@@ -180,10 +180,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,57 +195,6 @@ 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)
 	}
@@ -10,22 +10,6 @@ func equalInt(x, y int) bool {
 	return x == y
 }

-func divInt(x, y int) int {
-	return x / y
-}
-
-func divUint(x, y uint) uint {
-	return x / y
-}
-
-func remInt(x, y int) int {
-	return x % y
-}
-
-func remUint(x, y uint) uint {
-	return x % y
-}
-
 func floatEQ(x, y float32) bool {
 	return x == y
 }
@@ -71,18 +55,3 @@ func complexMul(x, y complex64) complex64 {
 }

 // 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)
-}
@@ -1,159 +1,74 @@
 ; ModuleID = 'basic.go'
 source_filename = "basic.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"

-%main.kv = type { float }
-%main.kv.0 = type { i8 }
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden i32 @main.addInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.addInt(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, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.equalInt(i32 %x, i32 %y, 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, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i32 %y, 0
-  br i1 %0, label %divbyzero.throw, label %divbyzero.next
-
-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
-  unreachable
-
-divbyzero.next:                                   ; preds = %entry
-  %1 = icmp eq i32 %y, -1
-  %2 = icmp eq i32 %x, -2147483648
-  %3 = and i1 %1, %2
-  %4 = select i1 %3, i32 1, i32 %y
-  %5 = sdiv i32 %x, %4
-  ret i32 %5
-}
-
-declare void @runtime.divideByZeroPanic(i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden i32 @main.divUint(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i32 %y, 0
-  br i1 %0, label %divbyzero.throw, label %divbyzero.next
-
-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
-  unreachable
-
-divbyzero.next:                                   ; preds = %entry
-  %1 = udiv i32 %x, %y
-  ret i32 %1
-}
-
-; Function Attrs: nounwind
-define hidden i32 @main.remInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i32 %y, 0
-  br i1 %0, label %divbyzero.throw, label %divbyzero.next
-
-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
-  unreachable
-
-divbyzero.next:                                   ; preds = %entry
-  %1 = icmp eq i32 %y, -1
-  %2 = icmp eq i32 %x, -2147483648
-  %3 = and i1 %1, %2
-  %4 = select i1 %3, i32 1, i32 %y
-  %5 = srem i32 %x, %4
-  ret i32 %5
-}
-
-; Function Attrs: nounwind
-define hidden i32 @main.remUint(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i32 %y, 0
-  br i1 %0, label %divbyzero.throw, label %divbyzero.next
-
-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
-  unreachable
-
-divbyzero.next:                                   ; preds = %entry
-  %1 = urem i32 %x, %y
-  ret i32 %1
-}
-
-; Function Attrs: nounwind
-define hidden i1 @main.floatEQ(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatEQ(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp oeq float %x, %y
  ret i1 %0
 }

-; Function Attrs: nounwind
-define hidden i1 @main.floatNE(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatNE(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp une float %x, %y
  ret i1 %0
 }

-; Function Attrs: nounwind
-define hidden i1 @main.floatLower(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatLower(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp olt float %x, %y
  ret i1 %0
 }

-; Function Attrs: nounwind
-define hidden i1 @main.floatLowerEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatLowerEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp ole float %x, %y
  ret i1 %0
 }

-; Function Attrs: nounwind
-define hidden i1 @main.floatGreater(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatGreater(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp ogt float %x, %y
  ret i1 %0
 }

-; Function Attrs: nounwind
-define hidden i1 @main.floatGreaterEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.floatGreaterEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fcmp oge float %x, %y
  ret i1 %0
 }

-; Function Attrs: nounwind
-define hidden float @main.complexReal(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden float @main.complexReal(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret float %x.r
 }

-; Function Attrs: nounwind
-define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret float %x.i
 }

-; Function Attrs: nounwind
-define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fadd float %x.r, %y.r
  %1 = fadd float %x.i, %y.i
@@ -162,8 +77,7 @@ entry:
  ret { float, float } %3
 }

-; Function Attrs: nounwind
-define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fsub float %x.r, %y.r
  %1 = fsub float %x.i, %y.i
@@ -172,8 +86,7 @@ entry:
  ret { float, float } %3
 }

-; Function Attrs: nounwind
-define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = fmul float %x.r, %y.r
  %1 = fmul float %x.i, %y.i
@@ -185,18 +98,3 @@ entry:
  %7 = insertvalue { float, float } %6, float %5, 1
  ret { float, float } %7
 }
-
-; Function Attrs: nounwind
-define hidden void @main.foo(%main.kv* dereferenceable_or_null(4) %a, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  call void @"main.foo$1"(%main.kv.0* null, i8* undef, i8* undef)
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @"main.foo$1"(%main.kv.0* dereferenceable_or_null(1) %b, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-attributes #0 = { nounwind }
@@ -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,122 +0,0 @@
-; ModuleID = 'channel.go'
-source_filename = "channel.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
-
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
-%"internal/task.state" = type { 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*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.chanIntSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.value = alloca i32, align 4
-  %chan.value.bitcast = bitcast i32* %chan.value to i8*
-  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  store i32 3, i32* %chan.value, align 4
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  ret void
-}
-
-; Function Attrs: argmemonly 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*, 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, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.value = alloca i32, align 4
-  %chan.value.bitcast = bitcast i32* %chan.value to i8*
-  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  ret void
-}
-
-declare i1 @runtime.chanRecv(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.chanZeroSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.chanZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.selectZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch1, %runtime.channel* dereferenceable_or_null(32) %ch2, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %select.states.alloca = alloca [2 x %runtime.chanSelectState], align 8
-  %select.send.value = alloca i32, align 4
-  store i32 1, i32* %select.send.value, align 4
-  %select.states.alloca.bitcast = bitcast [2 x %runtime.chanSelectState]* %select.states.alloca to i8*
-  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
-  %.repack = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 0
-  store %runtime.channel* %ch1, %runtime.channel** %.repack, align 8
-  %.repack1 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 1
-  %0 = bitcast i8** %.repack1 to i32**
-  store i32* %select.send.value, i32** %0, align 4
-  %.repack3 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 0
-  store %runtime.channel* %ch2, %runtime.channel** %.repack3, align 8
-  %.repack4 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 1
-  store i8* null, i8** %.repack4, align 4
-  %select.states = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0
-  %select.result = call { i32, i1 } @runtime.tryChanSelect(i8* undef, %runtime.chanSelectState* nonnull %select.states, i32 2, i32 2, i8* undef, i8* null) #0
-  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
-  %1 = extractvalue { i32, i1 } %select.result, 0
-  %2 = icmp eq i32 %1, 0
-  br i1 %2, label %select.done, label %select.next
-
-select.done:                                      ; preds = %select.body, %select.next, %entry
-  ret void
-
-select.next:                                      ; preds = %entry
-  %3 = icmp eq i32 %1, 1
-  br i1 %3, label %select.body, label %select.done
-
-select.body:                                      ; preds = %select.next
-  br label %select.done
-}
-
-declare { i32, i1 } @runtime.tryChanSelect(i8*, %runtime.chanSelectState*, i32, i32, i8*, i8*)
-
-attributes #0 = { nounwind }
-attributes #1 = { argmemonly nofree nosync nounwind willreturn }
@@ -1,18 +1,16 @@
 ; ModuleID = 'float.go'
 source_filename = "float.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden i32 @main.f32tou32(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.f32tou32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %positive = fcmp oge float %v, 0.000000e+00
  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -23,26 +21,22 @@ entry:
  ret i32 %0
 }

-; Function Attrs: nounwind
-define hidden float @main.maxu32f(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden float @main.maxu32f(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret float 0x41F0000000000000
 }

-; Function Attrs: nounwind
-define hidden i32 @main.maxu32tof32(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.maxu32tof32(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret i32 -1
 }

-; Function Attrs: nounwind
-define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret { i32, i32, i32, i32 } { i32 -1, i32 0, i32 2147483647, i32 -2147483648 }
 }

-; Function Attrs: nounwind
-define hidden i32 @main.u32tof32tou32(i32 %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.u32tof32tou32(i32 %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = uitofp i32 %v to float
  %withinmax = fcmp ole float %0, 0x41EFFFFFC0000000
@@ -51,8 +45,7 @@ entry:
  ret i32 %1
 }

-; Function Attrs: nounwind
-define hidden float @main.f32tou32tof32(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden float @main.f32tou32tof32(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %positive = fcmp oge float %v, 0.000000e+00
  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -64,8 +57,7 @@ entry:
  ret float %1
 }

-; Function Attrs: nounwind
-define hidden i8 @main.f32tou8(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8 @main.f32tou8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %positive = fcmp oge float %v, 0.000000e+00
  %withinmax = fcmp ole float %v, 2.550000e+02
@@ -76,8 +68,7 @@ entry:
  ret i8 %0
 }

-; Function Attrs: nounwind
-define hidden i8 @main.f32toi8(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8 @main.f32toi8(float %v, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %abovemin = fcmp oge float %v, -1.280000e+02
  %belowmax = fcmp ole float %v, 1.270000e+02
@@ -89,5 +80,3 @@ entry:
  %0 = select i1 %inbounds, i8 %normal, i8 %remapped
  ret i8 %0
 }
-
-attributes #0 = { nounwind }
@@ -1,35 +1,33 @@
 ; ModuleID = 'func.go'
 source_filename = "func.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"

 %runtime.funcValueWithSignature = type { i32, i8* }

@"reflect/types.funcid:func:{basic:int}{}" = external constant i8
@"main.someFunc$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @main.someFunc to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.foo(i8* %callback.context, i32 %callback.funcptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.foo(i8* %callback.context, i32 %callback.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i32 @runtime.getFuncPtr(i8* %callback.context, i32 %callback.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null) #0
+  %0 = call i32 @runtime.getFuncPtr(i8* %callback.context, i32 %callback.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null)
  %1 = icmp eq i32 %0, 0
  br i1 %1, label %fpcall.throw, label %fpcall.next

 fpcall.throw:                                     ; preds = %entry
-  call void @runtime.nilPanic(i8* undef, i8* null) #0
+  call void @runtime.nilPanic(i8* undef, i8* null)
  unreachable

 fpcall.next:                                      ; preds = %entry
  %2 = inttoptr i32 %0 to void (i32, i8*, i8*)*
-  call void %2(i32 3, i8* %callback.context, i8* undef) #0
+  call void %2(i32 3, i8* %callback.context, i8* undef)
  ret void
 }

@@ -37,17 +35,13 @@ declare i32 @runtime.getFuncPtr(i8*, i32, i8* dereferenceable_or_null(1), i8*, i

 declare void @runtime.nilPanic(i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.bar(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.bar(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  call void @main.foo(i8* undef, i32 ptrtoint (%runtime.funcValueWithSignature* @"main.someFunc$withSignature" to i32), i8* undef, i8* undef)
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.someFunc(i32 %arg0, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.someFunc(i32 %arg0, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }
-
-attributes #0 = { nounwind }
@@ -1,72 +0,0 @@
-package main
-
-var (
-	scalar1 *byte
-	scalar2 *int32
-	scalar3 *int64
-	scalar4 *float32
-
-	array1 *[3]byte
-	array2 *[71]byte
-	array3 *[3]*byte
-
-	struct1 *struct{}
-	struct2 *struct {
-		x int
-		y int
-	}
-	struct3 *struct {
-		x *byte
-		y [60]uintptr
-		z *byte
-	}
-
-	slice1 []byte
-	slice2 []*int
-	slice3 [][]byte
-)
-
-func newScalar() {
-	scalar1 = new(byte)
-	scalar2 = new(int32)
-	scalar3 = new(int64)
-	scalar4 = new(float32)
-}
-
-func newArray() {
-	array1 = new([3]byte)
-	array2 = new([71]byte)
-	array3 = new([3]*byte)
-}
-
-func newStruct() {
-	struct1 = new(struct{})
-	struct2 = new(struct {
-		x int
-		y int
-	})
-	struct3 = new(struct {
-		x *byte
-		y [60]uintptr
-		z *byte
-	})
-}
-
-func newFuncValue() *func() {
-	// On some platforms that use runtime.funcValue ("switch" style) function
-	// values, a func value is allocated as having two pointer words while the
-	// struct looks like {unsafe.Pointer; uintptr}. This is so that the interp
-	// package won't get confused, see getPointerBitmap in compiler/llvm.go for
-	// details.
-	return new(func())
-}
-
-func makeSlice() {
-	slice1 = make([]byte, 5)
-	slice2 = make([]*int, 5)
-	slice3 = make([][]byte, 5)
-}
-
-func makeInterface(v complex128) interface{} {
-	return v // always stored in an allocation
-}
@@ -1,112 +0,0 @@
-; ModuleID = 'gc.go'
-source_filename = "gc.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
-
-%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
-%runtime.interfaceMethodInfo = type { i8*, i32 }
-%runtime._interface = type { i32, i8* }
-
-@main.scalar1 = hidden global i8* null, align 4
-@main.scalar2 = hidden global i32* null, align 4
-@main.scalar3 = hidden global i64* null, align 4
-@main.scalar4 = hidden global float* null, align 4
-@main.array1 = hidden global [3 x i8]* null, align 4
-@main.array2 = hidden global [71 x i8]* null, align 4
-@main.array3 = hidden global [3 x i8*]* null, align 4
-@main.struct1 = hidden global {}* null, align 4
-@main.struct2 = hidden global { i32, i32 }* null, align 4
-@main.struct3 = hidden global { i8*, [60 x i32], i8* }* null, align 4
-@main.slice1 = hidden global { i8*, i32, i32 } zeroinitializer, align 8
-@main.slice2 = hidden global { i32**, i32, i32 } zeroinitializer, align 8
-@main.slice3 = hidden global { { i8*, i32, i32 }*, i32, i32 } zeroinitializer, align 8
-@"runtime/gc.layout:62-2000000000000001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c" \00\00\00\00\00\00\01" }
-@"reflect/types.type:basic:complex128" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* null, i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:basic:complex128", i32 0 }
-@"reflect/types.type:pointer:basic:complex128" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:complex128", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.newScalar(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %new = call i8* @runtime.alloc(i32 1, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new, i8** @main.scalar1, align 4
-  %new1 = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new1, i8** bitcast (i32** @main.scalar2 to i8**), align 4
-  %new2 = call i8* @runtime.alloc(i32 8, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new2, i8** bitcast (i64** @main.scalar3 to i8**), align 4
-  %new3 = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new3, i8** bitcast (float** @main.scalar4 to i8**), align 4
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.newArray(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %new = call i8* @runtime.alloc(i32 3, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new, i8** bitcast ([3 x i8]** @main.array1 to i8**), align 4
-  %new1 = call i8* @runtime.alloc(i32 71, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new1, i8** bitcast ([71 x i8]** @main.array2 to i8**), align 4
-  %new2 = call i8* @runtime.alloc(i32 12, i8* nonnull inttoptr (i32 67 to i8*), i8* undef, i8* null) #0
-  store i8* %new2, i8** bitcast ([3 x i8*]** @main.array3 to i8**), align 4
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.newStruct(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %new = call i8* @runtime.alloc(i32 0, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new, i8** bitcast ({}** @main.struct1 to i8**), align 4
-  %new1 = call i8* @runtime.alloc(i32 8, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %new1, i8** bitcast ({ i32, i32 }** @main.struct2 to i8**), align 4
-  %new2 = call i8* @runtime.alloc(i32 248, i8* bitcast ({ i32, [8 x i8] }* @"runtime/gc.layout:62-2000000000000001" to i8*), i8* undef, i8* null) #0
-  store i8* %new2, i8** bitcast ({ i8*, [60 x i32], i8* }** @main.struct3 to i8**), align 4
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden { i8*, void ()* }* @main.newFuncValue(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %new = call i8* @runtime.alloc(i32 8, i8* nonnull inttoptr (i32 197 to i8*), i8* undef, i8* null) #0
-  %0 = bitcast i8* %new to { i8*, void ()* }*
-  ret { i8*, void ()* }* %0
-}
-
-; Function Attrs: nounwind
-define hidden void @main.makeSlice(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %makeslice = call i8* @runtime.alloc(i32 5, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  store i8* %makeslice, i8** getelementptr inbounds ({ i8*, i32, i32 }, { i8*, i32, i32 }* @main.slice1, i32 0, i32 0), align 8
-  store i32 5, i32* getelementptr inbounds ({ i8*, i32, i32 }, { i8*, i32, i32 }* @main.slice1, i32 0, i32 1), align 4
-  store i32 5, i32* getelementptr inbounds ({ i8*, i32, i32 }, { i8*, i32, i32 }* @main.slice1, i32 0, i32 2), align 8
-  %makeslice1 = call i8* @runtime.alloc(i32 20, i8* nonnull inttoptr (i32 67 to i8*), i8* undef, i8* null) #0
-  store i8* %makeslice1, i8** bitcast ({ i32**, i32, i32 }* @main.slice2 to i8**), align 8
-  store i32 5, i32* getelementptr inbounds ({ i32**, i32, i32 }, { i32**, i32, i32 }* @main.slice2, i32 0, i32 1), align 4
-  store i32 5, i32* getelementptr inbounds ({ i32**, i32, i32 }, { i32**, i32, i32 }* @main.slice2, i32 0, i32 2), align 8
-  %makeslice3 = call i8* @runtime.alloc(i32 60, i8* nonnull inttoptr (i32 71 to i8*), i8* undef, i8* null) #0
-  store i8* %makeslice3, i8** bitcast ({ { i8*, i32, i32 }*, i32, i32 }* @main.slice3 to i8**), align 8
-  store i32 5, i32* getelementptr inbounds ({ { i8*, i32, i32 }*, i32, i32 }, { { i8*, i32, i32 }*, i32, i32 }* @main.slice3, i32 0, i32 1), align 4
-  store i32 5, i32* getelementptr inbounds ({ { i8*, i32, i32 }*, i32, i32 }, { { i8*, i32, i32 }*, i32, i32 }* @main.slice3, i32 0, i32 2), align 8
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden %runtime._interface @main.makeInterface(double %v.r, double %v.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef, i8* null) #0
-  %.repack = bitcast i8* %0 to double*
-  store double %v.r, double* %.repack, align 8
-  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
-  %1 = bitcast i8* %.repack1 to double*
-  store double %v.i, double* %1, align 8
-  %2 = insertvalue %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:complex128" to i32), i8* undef }, i8* %0, 1
-  ret %runtime._interface %2
-}
-
-attributes #0 = { nounwind }
@@ -1,41 +0,0 @@
-package main
-
-// Test changes to the language introduced in Go 1.17.
-// For details, see: https://tip.golang.org/doc/go1.17#language
-// These tests should be merged into the regular slice tests once Go 1.17 is the
-// minimun Go version for TinyGo.
-
-import "unsafe"
-
-func Add32(p unsafe.Pointer, len int) unsafe.Pointer {
-	return unsafe.Add(p, len)
-}
-
-func Add64(p unsafe.Pointer, len int64) unsafe.Pointer {
-	return unsafe.Add(p, len)
-}
-
-func SliceToArray(s []int) *[4]int {
-	return (*[4]int)(s)
-}
-
-func SliceToArrayConst() *[4]int {
-	s := make([]int, 6)
-	return (*[4]int)(s)
-}
-
-func SliceInt(ptr *int, len int) []int {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceUint16(ptr *byte, len uint16) []byte {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceUint64(ptr *int, len uint64) []int {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceInt64(ptr *int, len int64) []int {
-	return unsafe.Slice(ptr, len)
-}
@@ -1,147 +0,0 @@
-; ModuleID = 'go1.17.go'
-source_filename = "go1.17.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden i8* @main.Add32(i8* %p, i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = getelementptr i8, i8* %p, i32 %len
-  ret i8* %0
-}
-
-; Function Attrs: nounwind
-define hidden i8* @main.Add64(i8* %p, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = trunc i64 %len to i32
-  %1 = getelementptr i8, i8* %p, i32 %0
-  ret i8* %1
-}
-
-; Function Attrs: nounwind
-define hidden [4 x i32]* @main.SliceToArray(i32* %s.data, i32 %s.len, i32 %s.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp ult i32 %s.len, 4
-  br i1 %0, label %slicetoarray.throw, label %slicetoarray.next
-
-slicetoarray.throw:                               ; preds = %entry
-  call void @runtime.sliceToArrayPointerPanic(i8* undef, i8* null) #0
-  unreachable
-
-slicetoarray.next:                                ; preds = %entry
-  %1 = bitcast i32* %s.data to [4 x i32]*
-  ret [4 x i32]* %1
-}
-
-declare void @runtime.sliceToArrayPointerPanic(i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden [4 x i32]* @main.SliceToArrayConst(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %makeslice = call i8* @runtime.alloc(i32 24, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  br i1 false, label %slicetoarray.throw, label %slicetoarray.next
-
-slicetoarray.throw:                               ; preds = %entry
-  unreachable
-
-slicetoarray.next:                                ; preds = %entry
-  %0 = bitcast i8* %makeslice to [4 x i32]*
-  ret [4 x i32]* %0
-}
-
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceInt(i32* dereferenceable_or_null(4) %ptr, i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp ugt i32 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i32 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %6 = insertvalue { i32*, i32, i32 } %5, i32 %len, 1
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %len, 2
-  ret { i32*, i32, i32 } %7
-}
-
-declare void @runtime.unsafeSlicePanic(i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden { i8*, i32, i32 } @main.SliceUint16(i8* dereferenceable_or_null(1) %ptr, i16 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i8* %ptr, null
-  %1 = icmp ne i16 %len, 0
-  %2 = and i1 %0, %1
-  br i1 %2, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %3 = zext i16 %len to i32
-  %4 = insertvalue { i8*, i32, i32 } undef, i8* %ptr, 0
-  %5 = insertvalue { i8*, i32, i32 } %4, i32 %3, 1
-  %6 = insertvalue { i8*, i32, i32 } %5, i32 %3, 2
-  ret { i8*, i32, i32 } %6
-}
-
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceUint64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i64 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
-  ret { i32*, i32, i32 } %8
-}
-
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceInt64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i64 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
-  ret { i32*, i32, i32 } %8
-}
-
-attributes #0 = { nounwind }
@@ -1,7 +1,7 @@
 ; ModuleID = 'goroutine.go'
 source_filename = "goroutine.go"
 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv7m-unknown-unknown-eabi"
+target triple = "armv7m-none-eabi"

 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
 %runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
@@ -9,31 +9,26 @@ target triple = "thumbv7m-unknown-unknown-eabi"
 %"internal/task.state" = type { i32, i32* }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }

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

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef, i8* undef) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef, i8* undef)
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null)
  ret void
 }

 declare void @main.regularFunction(i32, i8*, i8*)

-; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #1 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #0 {
 entry:
  %unpack.int = ptrtoint i8* %0 to i32
-  call void @main.regularFunction(i32 %unpack.int, i8* undef, i8* undef) #0
+  call void @main.regularFunction(i32 %unpack.int, i8* undef, i8* undef)
  ret void
 }

@@ -41,57 +36,51 @@ declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*, i8*)

 declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef)
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null)
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #2 {
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #1 {
 entry:
  %unpack.int = ptrtoint i8* %0 to i32
  call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, i8* undef, i8* undef)
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %n = call i8* @runtime.alloc(i32 4, i8* undef, i8* null)
  %0 = bitcast i8* %n to i32*
  store i32 3, i32* %0, align 4
-  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
+  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
  %2 = bitcast i8* %1 to i32*
  store i32 5, i32* %2, align 4
  %3 = getelementptr inbounds i8, i8* %1, i32 4
  %4 = bitcast i8* %3 to i8**
  store i8* %n, i8** %4, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef, i8* null) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef)
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef, i8* null)
  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef, i8* null) #0
+  call void @runtime.printint32(i32 %5, i8* undef, i8* null)
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %unpack.ptr = bitcast i8* %context to i32*
  store i32 7, i32* %unpack.ptr, align 4
  ret void
 }

-; Function Attrs: nounwind
-define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #3 {
+define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #2 {
 entry:
  %1 = bitcast i8* %0 to i32*
  %2 = load i32, i32* %1, align 4
@@ -104,25 +93,23 @@ entry:

 declare void @runtime.printint32(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(i8* %fn.context, void ()* %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.funcGoroutine(i8* %fn.context, void (i32, i8*, i8*)* %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i8* @runtime.alloc(i32 12, i8* null, i8* undef, i8* null) #0
+  %0 = call i8* @runtime.alloc(i32 12, i8* undef, i8* null)
  %1 = bitcast i8* %0 to i32*
  store i32 5, i32* %1, align 4
  %2 = getelementptr inbounds i8, i8* %0, i32 4
  %3 = bitcast i8* %2 to i8**
  store i8* %fn.context, i8** %3, align 4
  %4 = getelementptr inbounds i8, i8* %0, i32 8
-  %5 = bitcast i8* %4 to void ()**
-  store void ()* %fn.funcptr, void ()** %5, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* undef, i8* undef) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null) #0
+  %5 = bitcast i8* %4 to void (i32, i8*, i8*)**
+  store void (i32, i8*, i8*)* %fn.funcptr, void (i32, i8*, i8*)** %5, align 4
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* undef, i8* undef)
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null)
  ret void
 }

-; Function Attrs: nounwind
-define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #4 {
+define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #3 {
 entry:
  %1 = bitcast i8* %0 to i32*
  %2 = load i32, i32* %1, align 4
@@ -132,78 +119,32 @@ entry:
  %6 = getelementptr inbounds i8, i8* %0, i32 8
  %7 = bitcast i8* %6 to void (i32, i8*, i8*)**
  %8 = load void (i32, i8*, i8*)*, void (i32, i8*, i8*)** %7, align 4
-  call void %8(i32 %2, i8* %5, i8* undef) #0
+  call void %8(i32 %2, i8* %5, i8* undef)
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null) #0
+  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null)
  ret void
 }

 declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null) #0
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
  ret void
 }

 declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)

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

 %runtime.funcValueWithSignature = type { i32, i8* }
 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
@@ -10,24 +10,21 @@ target triple = "wasm32-unknown-wasi"
 %"internal/task.state" = type { i8* }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }

-@"main$pack" = internal unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
-@"main$pack.1" = internal unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
+@"main.regularFunctionGoroutine$pack" = private unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
+@"main.inlineFunctionGoroutine$pack" = private unnamed_addr constant { i32, i8* } { i32 5, i8* undef }
@"reflect/types.funcid:func:{basic:int}{}" = external constant i8
@"main.closureFunctionGoroutine$1$withSignature" = linkonce_odr constant %runtime.funcValueWithSignature { i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* @"reflect/types.funcid:func:{basic:int}{}" }
-@"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @main.regularFunction to i32), i8* bitcast ({ i32, i8* }* @"main$pack" to i8*), i32 undef, i8* undef, i8* null) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @main.regularFunction to i32), i8* bitcast ({ i32, i8* }* @"main.regularFunctionGoroutine$pack" to i8*), i32 undef, i8* undef, i8* null)
  ret void
 }

@@ -35,39 +32,35 @@ declare void @main.regularFunction(i32, i8*, i8*)

 declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.inlineFunctionGoroutine$1" to i32), i8* bitcast ({ i32, i8* }* @"main$pack.1" to i8*), i32 undef, i8* undef, i8* null) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.inlineFunctionGoroutine$1" to i32), i8* bitcast ({ i32, i8* }* @"main.inlineFunctionGoroutine$pack" to i8*), i32 undef, i8* undef, i8* null)
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.closureFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %n = call i8* @runtime.alloc(i32 4, i8* undef, i8* null)
  %0 = bitcast i8* %n to i32*
  store i32 3, i32* %0, align 4
-  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
+  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
  %2 = bitcast i8* %1 to i32*
  store i32 5, i32* %2, align 4
  %3 = getelementptr inbounds i8, i8* %1, i32 4
  %4 = bitcast i8* %3 to i8**
  store i8* %n, i8** %4, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* nonnull %1, i32 undef, i8* undef, i8* null) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i32, i8*, i8*)* @"main.closureFunctionGoroutine$1" to i32), i8* nonnull %1, i32 undef, i8* undef, i8* null)
  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef, i8* null) #0
+  call void @runtime.printint32(i32 %5, i8* undef, i8* null)
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %unpack.ptr = bitcast i8* %context to i32*
  store i32 7, i32* %unpack.ptr, align 4
@@ -76,66 +69,38 @@ entry:

 declare void @runtime.printint32(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(i8* %fn.context, i32 %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.funcGoroutine(i8* %fn.context, i32 %fn.funcptr, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i32 @runtime.getFuncPtr(i8* %fn.context, i32 %fn.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null) #0
-  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
+  %0 = call i32 @runtime.getFuncPtr(i8* %fn.context, i32 %fn.funcptr, i8* nonnull @"reflect/types.funcid:func:{basic:int}{}", i8* undef, i8* null)
+  %1 = call i8* @runtime.alloc(i32 8, i8* undef, i8* null)
  %2 = bitcast i8* %1 to i32*
  store i32 5, i32* %2, align 4
  %3 = getelementptr inbounds i8, i8* %1, i32 4
  %4 = bitcast i8* %3 to i8**
  store i8* %fn.context, i8** %4, align 4
-  call void @"internal/task.start"(i32 %0, i8* nonnull %1, i32 undef, i8* undef, i8* null) #0
+  call void @"internal/task.start"(i32 %0, i8* nonnull %1, i32 undef, i8* undef, i8* null)
  ret void
 }

 declare i32 @runtime.getFuncPtr(i8*, i32, i8* dereferenceable_or_null(1), i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.recoverBuiltinGoroutine(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null) #0
+  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef, i8* null)
  ret void
 }

 declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null) #0
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef, i8* null)
  ret void
 }

 declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef, i8* null) #0
-  %1 = bitcast i8* %0 to i8**
-  store i8* %itf.value, i8** %1, align 4
-  %2 = getelementptr inbounds i8, i8* %0, i32 4
-  %.repack = bitcast i8* %2 to i8**
-  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main$string", i32 0, i32 0), i8** %.repack, align 4
-  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
-  %3 = bitcast i8* %.repack1 to i32*
-  store i32 4, i32* %3, align 4
-  %4 = getelementptr inbounds i8, i8* %0, i32 12
-  %5 = bitcast i8* %4 to i32*
-  store i32 %itf.typecode, i32* %5, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*, i8*, i32, i32, i8*, i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke" to i32), i8* nonnull %0, i32 undef, i8* undef, i8* null) #0
-  ret void
-}
-
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*, i8*) #1
-
-attributes #0 = { nounwind }
-attributes #1 = { "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
@@ -41,11 +41,3 @@ func closeBuiltinGoroutine(ch chan int) {
 }

 func regularFunction(x int)
-
-type simpleInterface interface {
-	Print(string)
-}
-
-func startInterfaceMethod(itf simpleInterface) {
-	go itf.Print("test")
-}
@@ -49,15 +49,6 @@ func isStringer(itf interface{}) bool {
 	return ok
 }

-type fooInterface interface {
-	String() string
-	foo(int) byte
-}
-
-func callFooMethod(itf fooInterface) uint8 {
-	return itf.foo(3)
-}
-
 func callErrorMethod(itf error) string {
 	return itf.Error()
 }
@@ -1,67 +1,58 @@
 ; ModuleID = 'interface.go'
 source_filename = "interface.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"

-%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
+%runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID* }
 %runtime.interfaceMethodInfo = type { i8*, i32 }
 %runtime._interface = type { i32, i8* }
 %runtime._string = type { i8*, i32 }

-@"reflect/types.type:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* null, i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:basic:int", i32 0 }
-@"reflect/types.type:pointer:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-@"reflect/types.type:pointer:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:named:error", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:named:error", i32 ptrtoint (i1 (i32)* @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
-@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{Error() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}", i32 ptrtoint (i1 (i32)* @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
+@"reflect/types.type:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* null, i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:basic:int" }
+@"reflect/types.type:pointer:basic:int" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
+@"reflect/types.type:pointer:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:named:error", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
+@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:named:error" }
+@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{Error() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" }
@"reflect/methods.Error() string" = linkonce_odr constant i8 0, align 1
@"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]
-@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{String:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null, i32 0 }
-@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{String() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", i32 ptrtoint (i1 (i32)* @"interface:{String:func:{}{basic:string}}.$typeassert" to i32) }
+@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
+@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:interface:{String:func:{}{basic:string}}", i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* null }
+@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { %runtime.typecodeID* bitcast ([1 x i8*]* @"reflect/types.interface:interface{String() string}$interface" to %runtime.typecodeID*), i32 0, %runtime.interfaceMethodInfo* null, %runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" }
@"reflect/methods.String() string" = linkonce_odr constant i8 0, align 1
@"reflect/types.interface:interface{String() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.String() string"]
@"reflect/types.typeid:basic:int" = external constant i8
+@"error$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.Error() string"]

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden %runtime._interface @main.simpleType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._interface @main.simpleType(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:int" to i32), i8* null }
 }

-; Function Attrs: nounwind
-define hidden %runtime._interface @main.pointerType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._interface @main.pointerType(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:basic:int" to i32), i8* null }
 }

-; Function Attrs: nounwind
-define hidden %runtime._interface @main.interfaceType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._interface @main.interfaceType(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:named:error" to i32), i8* null }
 }

-declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32) #1
-
-; Function Attrs: nounwind
-define hidden %runtime._interface @main.anonymousInterfaceType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._interface @main.anonymousInterfaceType(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret %runtime._interface { i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" to i32), i8* null }
 }

-declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32) #2
-
-; Function Attrs: nounwind
-define hidden i1 @main.isInt(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.isInt(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, i8* nonnull @"reflect/types.typeid:basic:int", i8* undef, i8* null) #0
+  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, i8* nonnull @"reflect/types.typeid:basic:int", i8* undef, i8* null)
  br i1 %typecode, label %typeassert.ok, label %typeassert.next

 typeassert.ok:                                    ; preds = %entry
@@ -73,10 +64,9 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent

 declare i1 @runtime.typeAssert(i32, i8* dereferenceable_or_null(1), i8*, i8*)

-; Function Attrs: nounwind
-define hidden i1 @main.isError(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.isError(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
+  %0 = call i1 @runtime.interfaceImplements(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"error$interface", i32 0, i32 0), i8* undef, i8* null)
  br i1 %0, label %typeassert.ok, label %typeassert.next

 typeassert.ok:                                    ; preds = %entry
@@ -86,10 +76,11 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent
  ret i1 %0
 }

-; Function Attrs: nounwind
-define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+declare i1 @runtime.interfaceImplements(i32, i8** dereferenceable_or_null(4), i8*, i8*)
+
+define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
+  %0 = call i1 @runtime.interfaceImplements(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"reflect/types.interface:interface{String() string}$interface", i32 0, i32 0), i8* undef, i8* null)
  br i1 %0, label %typeassert.ok, label %typeassert.next

 typeassert.ok:                                    ; preds = %entry
@@ -99,26 +90,12 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent
  ret i1 %0
 }

-; Function Attrs: nounwind
-define hidden i8 @main.callFooMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(i8* %itf.value, i32 3, i32 %itf.typecode, i8* undef, i8* undef) #0
-  ret i8 %0
-}
-
-declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(i8*, i32, i32, i8*, i8*) #3
-
-; Function Attrs: nounwind
-define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8* %itf.value, i32 %itf.typecode, i8* undef, i8* undef) #0
+  %invoke.func = call i32 @runtime.interfaceMethod(i32 %itf.typecode, i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"error$interface", i32 0, i32 0), i8* nonnull @"reflect/methods.Error() string", i8* undef, i8* null)
+  %invoke.func.cast = inttoptr i32 %invoke.func to %runtime._string (i8*, i8*, i8*)*
+  %0 = call %runtime._string %invoke.func.cast(i8* %itf.value, i8* undef, i8* undef)
  ret %runtime._string %0
 }

-declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8*, i32, i8*, i8*) #4
-
-attributes #0 = { nounwind }
-attributes #1 = { "tinygo-methods"="reflect/methods.Error() string" }
-attributes #2 = { "tinygo-methods"="reflect/methods.String() string" }
-attributes #3 = { "tinygo-invoke"="main.$methods.foo(int) byte" "tinygo-methods"="reflect/methods.String() string; main.$methods.foo(int) byte" }
-attributes #4 = { "tinygo-invoke"="reflect/methods.Error() string" "tinygo-methods"="reflect/methods.Error() string" }
+declare i32 @runtime.interfaceMethod(i32, i8** dereferenceable_or_null(4), i8* dereferenceable_or_null(1), i8*, i8*)
@@ -1,32 +0,0 @@
-; ModuleID = 'intrinsics.go'
-source_filename = "intrinsics.go"
-target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv7m-unknown-unknown-eabi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden double @main.mySqrt(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call double @math.Sqrt(double %x, i8* undef, i8* undef) #0
-  ret double %0
-}
-
-declare double @math.Sqrt(double, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden double @main.myTrunc(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call double @math.Trunc(double %x, i8* undef, i8* undef) #0
-  ret double %0
-}
-
-declare double @math.Trunc(double, i8*, i8*)
-
-attributes #0 = { nounwind }
@@ -1,35 +0,0 @@
-; ModuleID = 'intrinsics.go'
-source_filename = "intrinsics.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden double @main.mySqrt(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call double @llvm.sqrt.f64(double %x)
-  ret double %0
-}
-
-; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
-declare double @llvm.sqrt.f64(double) #1
-
-; Function Attrs: nounwind
-define hidden double @main.myTrunc(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = call double @llvm.trunc.f64(double %x)
-  ret double %0
-}
-
-; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
-declare double @llvm.trunc.f64(double) #1
-
-attributes #0 = { nounwind }
-attributes #1 = { nofree nosync nounwind readnone speculatable willreturn }
@@ -1,14 +0,0 @@
-package main
-
-// Test how intrinsics are lowered: either as regular calls to the math
-// functions or as LLVM builtins (such as llvm.sqrt.f64).
-
-import "math"
-
-func mySqrt(x float64) float64 {
-	return math.Sqrt(x)
-}
-
-func myTrunc(x float64) float64 {
-	return math.Trunc(x)
-}
@@ -1,61 +1,51 @@
 ; ModuleID = 'pointer.go'
 source_filename = "pointer.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret [0 x i32] zeroinitializer
 }

-; Function Attrs: nounwind
-define hidden i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = bitcast i8* %x to i32*
  ret i32* %0
 }

-; Function Attrs: nounwind
-define hidden i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = bitcast i32* %x to i8*
  ret i8* %0
 }

-; Function Attrs: nounwind
-define hidden i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret i8* %x
 }

-; Function Attrs: nounwind
-define hidden i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = getelementptr inbounds i8, i8* %ptr, i32 10
  ret i8* %0
 }

-; Function Attrs: nounwind
-define hidden i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = getelementptr inbounds i8, i8* %ptr, i32 %offset
  ret i8* %0
 }

-; Function Attrs: nounwind
-define hidden i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %0 = getelementptr i32, i32* %ptr, i32 %offset
  ret i32* %0
 }
-
-attributes #0 = { nounwind }
@@ -1,7 +1,7 @@
 ; ModuleID = 'pragma.go'
 source_filename = "pragma.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"

@extern_global = external global [0 x i8], align 1
@main.alignedGlobal = hidden global [4 x i32] zeroinitializer, align 32
@@ -10,56 +10,50 @@ target triple = "wasm32-unknown-wasi"
@undefinedGlobalNotInSection = external global i32, align 4
@main.multipleGlobalPragmas = hidden global i32 0, section ".global_section", align 1024

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define void @extern_func() #1 {
+define void @extern_func() #0 {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @somepkg.someFunction1(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @somepkg.someFunction1(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

 declare void @somepkg.someFunction2(i8*, i8*)

-; Function Attrs: inlinehint nounwind
-define hidden void @main.inlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #2 {
+; Function Attrs: inlinehint
+define hidden void @main.inlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #1 {
 entry:
  ret void
 }

-; Function Attrs: noinline nounwind
-define hidden void @main.noinlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #3 {
+; Function Attrs: noinline
+define hidden void @main.noinlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #2 {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden void @main.functionInSection(i8* %context, i8* %parentHandle) unnamed_addr #0 section ".special_function_section" {
+define hidden void @main.functionInSection(i8* %context, i8* %parentHandle) unnamed_addr section ".special_function_section" {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define void @exportedFunctionInSection() #4 section ".special_function_section" {
+define void @exportedFunctionInSection() #3 section ".special_function_section" {
 entry:
  ret void
 }

 declare void @main.undefinedFunctionNotInSection(i8*, i8*)

-attributes #0 = { nounwind }
-attributes #1 = { nounwind "wasm-export-name"="extern_func" }
-attributes #2 = { inlinehint nounwind }
-attributes #3 = { noinline nounwind }
-attributes #4 = { nounwind "wasm-export-name"="exportedFunctionInSection" }
+attributes #0 = { "wasm-export-name"="extern_func" }
+attributes #1 = { inlinehint }
+attributes #2 = { noinline }
+attributes #3 = { "wasm-export-name"="exportedFunctionInSection" }
@@ -23,21 +23,3 @@ func sliceAppendSlice(ints, added []int) []int {
 func sliceCopy(dst, src []int) int {
 	return copy(dst, src)
 }
-
-// Test bounds checking in *ssa.MakeSlice instruction.
-
-func makeByteSlice(len int) []byte {
-	return make([]byte, len)
-}
-
-func makeInt16Slice(len int) []int16 {
-	return make([]int16, len)
-}
-
-func makeArraySlice(len int) [][3]byte {
-	return make([][3]byte, len) // slice with element size of 3
-}
-
-func makeInt32Slice(len int) []int32 {
-	return make([]int32, len)
-}
@@ -1,36 +1,32 @@
 ; ModuleID = 'slice.go'
 source_filename = "slice.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret i32 %ints.len
 }

-; Function Attrs: nounwind
-define hidden i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret i32 %ints.cap
 }

-; Function Attrs: nounwind
-define hidden i32 @main.sliceElement(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.sliceElement(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %.not = icmp ult i32 %index, %ints.len
  br i1 %.not, label %lookup.next, label %lookup.throw

 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef, i8* null) #0
+  call void @runtime.lookupPanic(i8* undef, i8* null)
  unreachable

 lookup.next:                                      ; preds = %entry
@@ -41,10 +37,9 @@ lookup.next:                                      ; preds = %entry

 declare void @runtime.lookupPanic(i8*, i8*)

-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.sliceAppendValues(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { i32*, i32, i32 } @main.sliceAppendValues(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %varargs = call i8* @runtime.alloc(i32 12, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
+  %varargs = call i8* @runtime.alloc(i32 12, i8* undef, i8* null)
  %0 = bitcast i8* %varargs to i32*
  store i32 1, i32* %0, align 4
  %1 = getelementptr inbounds i8, i8* %varargs, i32 4
@@ -54,7 +49,7 @@ entry:
  %4 = bitcast i8* %3 to i32*
  store i32 3, i32* %4, align 4
  %append.srcPtr = bitcast i32* %ints.data to i8*
-  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, i8* undef, i8* null) #0
+  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, i8* undef, i8* null)
  %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
  %append.newBuf = bitcast i8* %append.newPtr to i32*
  %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
@@ -67,12 +62,11 @@ entry:

 declare { i8*, i32, i32 } @runtime.sliceAppend(i8*, i8* nocapture readonly, i32, i32, i32, i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.sliceAppendSlice(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32* %added.data, i32 %added.len, i32 %added.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden { i32*, i32, i32 } @main.sliceAppendSlice(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32* %added.data, i32 %added.len, i32 %added.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %append.srcPtr = bitcast i32* %ints.data to i8*
  %append.srcPtr1 = bitcast i32* %added.data to i8*
-  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* %append.srcPtr1, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, i8* undef, i8* null) #0
+  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* %append.srcPtr1, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, i8* undef, i8* null)
  %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
  %append.newBuf = bitcast i8* %append.newPtr to i32*
  %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
@@ -83,95 +77,12 @@ entry:
  ret { i32*, i32, i32 } %2
 }

-; Function Attrs: nounwind
-define hidden i32 @main.sliceCopy(i32* %dst.data, i32 %dst.len, i32 %dst.cap, i32* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.sliceCopy(i32* %dst.data, i32 %dst.len, i32 %dst.cap, i32* %src.data, i32 %src.len, i32 %src.cap, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %copy.dstPtr = bitcast i32* %dst.data to i8*
  %copy.srcPtr = bitcast i32* %src.data to i8*
-  %copy.n = call i32 @runtime.sliceCopy(i8* %copy.dstPtr, i8* %copy.srcPtr, i32 %dst.len, i32 %src.len, i32 4, i8* undef, i8* null) #0
+  %copy.n = call i32 @runtime.sliceCopy(i8* %copy.dstPtr, i8* %copy.srcPtr, i32 %dst.len, i32 %src.len, i32 4, i8* undef, i8* null)
  ret i32 %copy.n
 }

 declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden { i8*, i32, i32 } @main.makeByteSlice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %slice.maxcap = icmp slt i32 %len, 0
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null) #0
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.buf = call i8* @runtime.alloc(i32 %len, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  %0 = insertvalue { i8*, i32, i32 } undef, i8* %makeslice.buf, 0
-  %1 = insertvalue { i8*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i8*, i32, i32 } %1, i32 %len, 2
-  ret { i8*, i32, i32 } %2
-}
-
-declare void @runtime.slicePanic(i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden { i16*, i32, i32 } @main.makeInt16Slice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %slice.maxcap = icmp slt i32 %len, 0
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null) #0
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.cap = shl i32 %len, 1
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  %makeslice.array = bitcast i8* %makeslice.buf to i16*
-  %0 = insertvalue { i16*, i32, i32 } undef, i16* %makeslice.array, 0
-  %1 = insertvalue { i16*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i16*, i32, i32 } %1, i32 %len, 2
-  ret { i16*, i32, i32 } %2
-}
-
-; Function Attrs: nounwind
-define hidden { [3 x i8]*, i32, i32 } @main.makeArraySlice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %slice.maxcap = icmp ugt i32 %len, 1431655765
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null) #0
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.cap = mul i32 %len, 3
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  %makeslice.array = bitcast i8* %makeslice.buf to [3 x i8]*
-  %0 = insertvalue { [3 x i8]*, i32, i32 } undef, [3 x i8]* %makeslice.array, 0
-  %1 = insertvalue { [3 x i8]*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { [3 x i8]*, i32, i32 } %1, i32 %len, 2
-  ret { [3 x i8]*, i32, i32 } %2
-}
-
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.makeInt32Slice(i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %slice.maxcap = icmp ugt i32 %len, 1073741823
-  br i1 %slice.maxcap, label %slice.throw, label %slice.next
-
-slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef, i8* null) #0
-  unreachable
-
-slice.next:                                       ; preds = %entry
-  %makeslice.cap = shl i32 %len, 2
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
-  %makeslice.array = bitcast i8* %makeslice.buf to i32*
-  %0 = insertvalue { i32*, i32, i32 } undef, i32* %makeslice.array, 0
-  %1 = insertvalue { i32*, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i32*, i32, i32 } %1, i32 %len, 2
-  ret { i32*, i32, i32 } %2
-}
-
-attributes #0 = { nounwind }
@@ -27,8 +27,3 @@ func stringCompareUnequal(s1, s2 string) bool {
 func stringCompareLarger(s1, s2 string) bool {
 	return s1 > s2
 }
-
-func stringLookup(s string, x uint8) byte {
-	// Test that x is correctly extended to an uint before comparison.
-	return s[x]
-}
@@ -1,46 +1,41 @@
 ; ModuleID = 'string.go'
 source_filename = "string.go"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-wasi"
+target triple = "wasm32--wasi"

 %runtime._string = type { i8*, i32 }

-@"main$string" = internal unnamed_addr constant [3 x i8] c"foo", align 1
+@"main.someString$string" = internal unnamed_addr constant [3 x i8] c"foo", align 1

-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret void
 }

-; Function Attrs: nounwind
-define hidden %runtime._string @main.someString(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._string @main.someString(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  ret %runtime._string { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @"main$string", i32 0, i32 0), i32 3 }
+  ret %runtime._string { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @"main.someString$string", i32 0, i32 0), i32 3 }
 }

-; Function Attrs: nounwind
-define hidden %runtime._string @main.zeroLengthString(i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden %runtime._string @main.zeroLengthString(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret %runtime._string zeroinitializer
 }

-; Function Attrs: nounwind
-define hidden i32 @main.stringLen(i8* %s.data, i32 %s.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i32 @main.stringLen(i8* %s.data, i32 %s.len, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  ret i32 %s.len
 }

-; Function Attrs: nounwind
-define hidden i8 @main.stringIndex(i8* %s.data, i32 %s.len, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i8 @main.stringIndex(i8* %s.data, i32 %s.len, i32 %index, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
  %.not = icmp ult i32 %index, %s.len
  br i1 %.not, label %lookup.next, label %lookup.throw

 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef, i8* null) #0
+  call void @runtime.lookupPanic(i8* undef, i8* null)
  unreachable

 lookup.next:                                      ; preds = %entry
@@ -51,47 +46,26 @@ lookup.next:                                      ; preds = %entry

 declare void @runtime.lookupPanic(i8*, i8*)

-; Function Attrs: nounwind
-define hidden i1 @main.stringCompareEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.stringCompareEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null) #0
+  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null)
  ret i1 %0
 }

 declare i1 @runtime.stringEqual(i8*, i32, i8*, i32, i8*, i8*)

-; Function Attrs: nounwind
-define hidden i1 @main.stringCompareUnequal(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.stringCompareUnequal(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null) #0
+  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null)
  %1 = xor i1 %0, true
  ret i1 %1
 }

-; Function Attrs: nounwind
-define hidden i1 @main.stringCompareLarger(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
+define hidden i1 @main.stringCompareLarger(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
-  %0 = call i1 @runtime.stringLess(i8* %s2.data, i32 %s2.len, i8* %s1.data, i32 %s1.len, i8* undef, i8* null) #0
-  ret i1 %0
+  %0 = call i1 @runtime.stringLess(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef, i8* null)
+  %1 = xor i1 %0, true
+  ret i1 %1
 }

 declare i1 @runtime.stringLess(i8*, i32, i8*, i32, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden i8 @main.stringLookup(i8* %s.data, i32 %s.len, i8 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
-entry:
-  %0 = zext i8 %x to i32
-  %.not = icmp ult i32 %0, %s.len
-  br i1 %.not, label %lookup.next, label %lookup.throw
-
-lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef, i8* null) #0
-  unreachable
-
-lookup.next:                                      ; preds = %entry
-  %1 = getelementptr inbounds i8, i8* %s.data, i32 %0
-  %2 = load i8, i8* %1, align 1
-  ret i8 %2
-}
-
-attributes #0 = { nounwind }
@@ -1,18 +1,16 @@
 module github.com/tinygo-org/tinygo

-go 1.15
+go 1.16

 require (
-	github.com/aykevl/go-wasm v0.0.2-0.20211119014117-0761b1ddcd1a // indirect
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
 	github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693
 	github.com/chromedp/chromedp v0.6.4
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
 	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
 	github.com/mattn/go-colorable v0.1.8
-	go.bug.st/serial v1.1.3
-	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	golang.org/x/sys v0.0.0-20210510120138-977fb7262007
-	golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9
-	tinygo.org/x/go-llvm v0.0.0-20210907125547-fd2d62ea06be
+	go.bug.st/serial v1.1.2
+	golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78
+	golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2
+	tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c
 )
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
BCG	6b6b2bfc59	Adding extra files for testing multiline, globbing, etc.	2021-07-23 17:07:25 -04:00
BCG	778c79cc85	Started parsing of //go:embed pragmas	2021-07-19 20:12:44 -04:00